@launch77/cli 1.4.1 → 1.4.4

package/src/modules/plugin/lib/plugin-resolver.test.ts

@@ -1,99 +1,106 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import * as path from 'path'
 import * as os from 'os'
+import * as path from 'path'
+
 import fs from 'fs-extra'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 
-import { validatePluginInput, toNpmPackageName, resolvePluginLocation } from './plugin-resolver.js'
+import { PluginResolver } from './plugin-resolver.js'
 
 describe('Plugin Resolver', () => {
-  describe('validatePluginInput', () => {
+  let resolver: PluginResolver
+
+  beforeEach(() => {
+    resolver = new PluginResolver()
+  })
+
+  describe('validateInput', () => {
     it('should accept valid unscoped plugin names', () => {
-      expect(validatePluginInput('release')).toEqual({ isValid: true })
-      expect(validatePluginInput('my-plugin')).toEqual({ isValid: true })
-      expect(validatePluginInput('analytics-v2')).toEqual({ isValid: true })
+      expect(resolver.validateInput('release')).toEqual({ isValid: true })
+      expect(resolver.validateInput('my-plugin')).toEqual({ isValid: true })
+      expect(resolver.validateInput('analytics-v2')).toEqual({ isValid: true })
     })
 
     it('should accept valid scoped npm packages', () => {
-      expect(validatePluginInput('@ibm/plugin-name')).toEqual({ isValid: true })
-      expect(validatePluginInput('@launch77-shared/plugin-release')).toEqual({ isValid: true })
-      expect(validatePluginInput('@org/analytics')).toEqual({ isValid: true })
+      expect(resolver.validateInput('@ibm/plugin-name')).toEqual({ isValid: true })
+      expect(resolver.validateInput('@launch77-shared/plugin-release')).toEqual({ isValid: true })
+      expect(resolver.validateInput('@org/analytics')).toEqual({ isValid: true })
     })
 
     it('should reject empty names', () => {
-      const result = validatePluginInput('')
+      const result = resolver.validateInput('')
       expect(result.isValid).toBe(false)
       expect(result.error).toBeDefined()
     })
 
     it('should reject whitespace-only names', () => {
-      const result = validatePluginInput('   ')
+      const result = resolver.validateInput('   ')
       expect(result.isValid).toBe(false)
       expect(result.error).toBeDefined()
     })
 
     it('should reject invalid scoped packages', () => {
-      const result1 = validatePluginInput('@invalid')
+      const result1 = resolver.validateInput('@invalid')
       expect(result1.isValid).toBe(false)
       expect(result1.error).toBeDefined()
 
-      const result2 = validatePluginInput('@/package')
+      const result2 = resolver.validateInput('@/package')
       expect(result2.isValid).toBe(false)
       expect(result2.error).toBeDefined()
 
-      const result3 = validatePluginInput('@org/')
+      const result3 = resolver.validateInput('@org/')
       expect(result3.isValid).toBe(false)
       expect(result3.error).toBeDefined()
     })
 
     it('should reject names with uppercase letters', () => {
-      const result = validatePluginInput('MyPlugin')
+      const result = resolver.validateInput('MyPlugin')
       expect(result.isValid).toBe(false)
       expect(result.error).toContain('lowercase')
     })
 
     it('should reject names starting with numbers', () => {
-      const result = validatePluginInput('123plugin')
+      const result = resolver.validateInput('123plugin')
       expect(result.isValid).toBe(false)
       expect(result.error).toBeDefined()
     })
 
     it('should reject names with special characters', () => {
-      const result1 = validatePluginInput('plugin_name')
+      const result1 = resolver.validateInput('plugin_name')
       expect(result1.isValid).toBe(false)
 
-      const result2 = validatePluginInput('plugin.name')
+      const result2 = resolver.validateInput('plugin.name')
       expect(result2.isValid).toBe(false)
 
-      const result3 = validatePluginInput('plugin name')
+      const result3 = resolver.validateInput('plugin name')
       expect(result3.isValid).toBe(false)
     })
 
     it('should trim whitespace before validation', () => {
-      expect(validatePluginInput('  release  ')).toEqual({ isValid: true })
-      expect(validatePluginInput('  @ibm/analytics  ')).toEqual({ isValid: true })
+      expect(resolver.validateInput('  release  ')).toEqual({ isValid: true })
+      expect(resolver.validateInput('  @ibm/analytics  ')).toEqual({ isValid: true })
     })
   })
 
   describe('toNpmPackageName', () => {
     it('should prefix unscoped names with @launch77-shared/plugin-', () => {
-      expect(toNpmPackageName('release')).toBe('@launch77-shared/plugin-release')
-      expect(toNpmPackageName('my-plugin')).toBe('@launch77-shared/plugin-my-plugin')
-      expect(toNpmPackageName('analytics-v2')).toBe('@launch77-shared/plugin-analytics-v2')
+      expect(resolver.toNpmPackageName('release')).toBe('@launch77-shared/plugin-release')
+      expect(resolver.toNpmPackageName('my-plugin')).toBe('@launch77-shared/plugin-my-plugin')
+      expect(resolver.toNpmPackageName('analytics-v2')).toBe('@launch77-shared/plugin-analytics-v2')
     })
 
     it('should return scoped packages as-is', () => {
-      expect(toNpmPackageName('@ibm/analytics')).toBe('@ibm/analytics')
-      expect(toNpmPackageName('@launch77-shared/plugin-release')).toBe('@launch77-shared/plugin-release')
-      expect(toNpmPackageName('@org/package')).toBe('@org/package')
+      expect(resolver.toNpmPackageName('@ibm/analytics')).toBe('@ibm/analytics')
+      expect(resolver.toNpmPackageName('@launch77-shared/plugin-release')).toBe('@launch77-shared/plugin-release')
+      expect(resolver.toNpmPackageName('@org/package')).toBe('@org/package')
     })
 
     it('should trim whitespace', () => {
-      expect(toNpmPackageName('  release  ')).toBe('@launch77-shared/plugin-release')
-      expect(toNpmPackageName('  @ibm/analytics  ')).toBe('@ibm/analytics')
+      expect(resolver.toNpmPackageName('  release  ')).toBe('@launch77-shared/plugin-release')
+      expect(resolver.toNpmPackageName('  @ibm/analytics  ')).toBe('@ibm/analytics')
     })
   })
 
-  describe('resolvePluginLocation', () => {
+  describe('resolveLocation', () => {
     let tempDir: string
 
     beforeEach(async () => {
@@ -115,7 +122,7 @@ describe('Plugin Resolver', () => {
       await fs.writeFile(path.join(pluginPath, 'plugin.json'), JSON.stringify({ name: 'my-plugin', version: '1.0.0' }))
       await fs.writeFile(path.join(pluginPath, 'dist/generator.js'), 'console.log("test")')
 
-      const result = await resolvePluginLocation('my-plugin', tempDir)
+      const result = await resolver.resolveLocation('my-plugin', tempDir)
 
       expect(result).toEqual({
         source: 'local',
@@ -125,7 +132,7 @@ describe('Plugin Resolver', () => {
     })
 
     it('should resolve to npm if local plugin does not exist', async () => {
-      const result = await resolvePluginLocation('release', tempDir)
+      const result = await resolver.resolveLocation('release', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -141,7 +148,7 @@ describe('Plugin Resolver', () => {
       await fs.ensureDir(path.join(pluginPath, 'dist'))
       await fs.writeFile(path.join(pluginPath, 'dist/generator.js'), 'console.log("test")')
 
-      const result = await resolvePluginLocation('incomplete', tempDir)
+      const result = await resolver.resolveLocation('incomplete', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -156,7 +163,7 @@ describe('Plugin Resolver', () => {
       await fs.ensureDir(pluginPath)
       await fs.writeFile(path.join(pluginPath, 'plugin.json'), JSON.stringify({ name: 'incomplete', version: '1.0.0' }))
 
-      const result = await resolvePluginLocation('incomplete', tempDir)
+      const result = await resolver.resolveLocation('incomplete', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -170,7 +177,7 @@ describe('Plugin Resolver', () => {
       const pluginPath = path.join(tempDir, 'plugins', '@ibm')
       await fs.ensureDir(pluginPath)
 
-      const result = await resolvePluginLocation('@ibm/analytics', tempDir)
+      const result = await resolver.resolveLocation('@ibm/analytics', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -180,7 +187,7 @@ describe('Plugin Resolver', () => {
     })
 
     it('should resolve scoped @launch77-shared packages to npm', async () => {
-      const result = await resolvePluginLocation('@launch77-shared/plugin-release', tempDir)
+      const result = await resolver.resolveLocation('@launch77-shared/plugin-release', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -193,7 +200,7 @@ describe('Plugin Resolver', () => {
       // Remove plugins directory
       await fs.remove(path.join(tempDir, 'plugins'))
 
-      const result = await resolvePluginLocation('release', tempDir)
+      const result = await resolver.resolveLocation('release', tempDir)
 
       expect(result).toEqual({
         source: 'npm',
@@ -203,7 +210,7 @@ describe('Plugin Resolver', () => {
     })
 
     it('should trim whitespace from plugin names', async () => {
-      const result = await resolvePluginLocation('  release  ', tempDir)
+      const result = await resolver.resolveLocation('  release  ', tempDir)
 
       expect(result).toEqual({
         source: 'npm',

package/src/modules/plugin/lib/plugin-resolver.ts

@@ -1,160 +1,30 @@
 import * as path from 'path'
 
 import fs from 'fs-extra'
-import { parsePluginName, isValidNpmPackageName } from '@launch77/plugin-runtime'
 
-import type { ValidationResult } from '@launch77/plugin-runtime'
+import { PackageResolver } from '../../../infrastructure/package-resolver.js'
 
 /**
- * Plugin resolution result
- */
-export interface PluginResolution {
-  /** The source of the plugin */
-  source: 'local' | 'npm'
-  /** The resolved name/package to use */
-  resolvedName: string
-  /** The local path if source is 'local' */
-  localPath?: string
-  /** The npm package name if source is 'npm' */
-  npmPackage?: string
-}
-
-/**
- * Validate plugin input name
- *
- * Accepts:
- * - Unscoped names (e.g., "release", "my-plugin")
- * - Scoped npm packages (e.g., "@ibm/plugin-name")
+ * Plugin resolver implementation
  *
- * Rejects:
- * - Invalid formats
- * - Empty strings
- * - Names with invalid characters
- *
- * @param name - The plugin name to validate
- * @returns ValidationResult with isValid and optional error message
- *
- * @example
- * validatePluginInput('release') // { isValid: true }
- * validatePluginInput('@ibm/analytics') // { isValid: true }
- * validatePluginInput('@invalid') // { isValid: false, error: '...' }
+ * Resolves plugins from:
+ * - Local workspace plugins/ directory
+ * - npm packages with @launch77-shared/plugin- prefix
  */
-export function validatePluginInput(name: string): ValidationResult {
-  if (!name || name.trim().length === 0) {
-    return {
-      isValid: false,
-      error: 'Plugin name cannot be empty',
-    }
+export class PluginResolver extends PackageResolver {
+  protected getFolderName(): string {
+    return 'plugins'
   }
 
-  const trimmedName = name.trim()
-
-  // Parse the name to determine type and validate
-  const parsed = parsePluginName(trimmedName)
-
-  if (!parsed.isValid) {
-    return {
-      isValid: false,
-      error: parsed.error,
-    }
+  protected getPackagePrefix(): string {
+    return '@launch77-shared/plugin-'
   }
 
-  // If it's scoped, it must be a valid npm package name
-  if (parsed.type === 'scoped') {
-    return isValidNpmPackageName(trimmedName)
-  }
-
-  // Unscoped names are valid for both local and npm
-  return { isValid: true }
-}
-
-/**
- * Convert an unscoped plugin name to an npm package name
- *
- * Rules:
- * - Unscoped names: prefix with @launch77-shared/plugin-
- * - Scoped names: use as-is
- *
- * @param name - The plugin name (must be validated first)
- * @returns The npm package name
- *
- * @example
- * toNpmPackageName('release') // '@launch77-shared/plugin-release'
- * toNpmPackageName('@ibm/analytics') // '@ibm/analytics'
- */
-export function toNpmPackageName(name: string): string {
-  const trimmedName = name.trim()
-
-  // If already scoped, use as-is
-  if (trimmedName.startsWith('@')) {
-    return trimmedName
-  }
-
-  // Otherwise, convert to @launch77-shared/plugin-<name>
-  return `@launch77-shared/plugin-${trimmedName}`
-}
-
-/**
- * Resolve plugin location from name
- *
- * Resolution order:
- * 1. Check local workspace plugins directory
- * 2. Resolve to npm package name
- *
- * @param name - The plugin name to resolve
- * @param workspaceRoot - The workspace root directory
- * @returns PluginResolution with source and resolved location
- *
- * @example
- * // Local plugin found
- * await resolvePluginLocation('my-plugin', '/workspace')
- * // { source: 'local', resolvedName: 'my-plugin', localPath: '/workspace/plugins/my-plugin' }
- *
- * // Not found locally, resolve to npm
- * await resolvePluginLocation('release', '/workspace')
- * // { source: 'npm', resolvedName: 'release', npmPackage: '@launch77-shared/plugin-release' }
- *
- * // Scoped package always resolves to npm
- * await resolvePluginLocation('@ibm/analytics', '/workspace')
- * // { source: 'npm', resolvedName: '@ibm/analytics', npmPackage: '@ibm/analytics' }
- */
-export async function resolvePluginLocation(name: string, workspaceRoot: string): Promise<PluginResolution> {
-  const trimmedName = name.trim()
-  const parsed = parsePluginName(trimmedName)
-
-  // If scoped, always use npm (local plugins are never scoped)
-  if (parsed.type === 'scoped') {
-    return {
-      source: 'npm',
-      resolvedName: trimmedName,
-      npmPackage: trimmedName,
-    }
-  }
-
-  // Check local workspace plugins directory
-  const localPath = path.join(workspaceRoot, 'plugins', trimmedName)
-  const localExists = await fs.pathExists(localPath)
-
-  if (localExists) {
+  protected async verify(localPath: string): Promise<boolean> {
     // Verify it's a valid plugin (has plugin.json and dist/generator.js)
     const hasPluginJson = await fs.pathExists(path.join(localPath, 'plugin.json'))
     const hasGenerator = await fs.pathExists(path.join(localPath, 'dist/generator.js'))
 
-    if (hasPluginJson && hasGenerator) {
-      return {
-        source: 'local',
-        resolvedName: trimmedName,
-        localPath,
-      }
-    }
-  }
-
-  // Not found locally, resolve to npm package
-  const npmPackage = toNpmPackageName(trimmedName)
-
-  return {
-    source: 'npm',
-    resolvedName: trimmedName,
-    npmPackage,
+    return hasPluginJson && hasGenerator
   }
 }

package/src/modules/plugin/services/plugin-svc.ts

@@ -5,8 +5,9 @@ import chalk from 'chalk'
 import { execa } from 'execa'
 import { readPluginMetadata } from '@launch77/plugin-runtime'
 
+import { downloadNpmPackage } from '../../../infrastructure/npm-package.js'
 import { PluginInstallationError, InvalidPluginContextError, createInvalidContextError, MissingPluginTargetsError, createInvalidTargetError, NpmInstallationError, PluginResolutionError } from '../errors/plugin-errors.js'
-import { validatePluginInput, resolvePluginLocation } from '../lib/plugin-resolver.js'
+import { PluginResolver } from '../lib/plugin-resolver.js'
 
 import type { Launch77Context, Launch77LocationType, Launch77PackageManifest, InstalledPluginMetadata, PluginMetadata } from '@launch77/plugin-runtime'
 import type { InstallPluginRequest, InstallPluginResult } from '../types/plugin-types.js'
@@ -30,6 +31,12 @@ function locationTypeToTarget(locationType: Launch77LocationType): string | null
 }
 
 export class PluginService {
+  private pluginResolver: PluginResolver
+
+  constructor() {
+    this.pluginResolver = new PluginResolver()
+  }
+
   /**
    * Validate that we're in a valid package directory and return the target type
    */
@@ -47,14 +54,14 @@ export class PluginService {
     logger(chalk.blue(`\n🔍 Resolving plugin "${pluginName}"...`))
     logger(`  ├─ Validating plugin name...`)
 
-    const validation = validatePluginInput(pluginName)
+    const validation = this.pluginResolver.validateInput(pluginName)
     if (!validation.isValid) {
       throw new PluginResolutionError(pluginName, validation.error || 'Invalid plugin name')
     }
     logger(`  │  └─ ${chalk.green('✓')} Valid plugin name`)
 
     logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
-    const resolution = await resolvePluginLocation(pluginName, workspaceRoot)
+    const resolution = await this.pluginResolver.resolveLocation(pluginName, workspaceRoot)
 
     let pluginPath: string
 
@@ -154,19 +161,12 @@ export class PluginService {
   private async downloadNpmPlugin(npmPackage: string, workspaceRoot: string, logger: (message: string) => void): Promise<string> {
     logger(`  └─ Installing from npm: ${chalk.cyan(npmPackage)}...`)
 
-    try {
-      // Install the npm package to the workspace
-      await execa('npm', ['install', npmPackage, '--save-dev'], {
-        cwd: workspaceRoot,
-        stdio: 'pipe', // Capture output for clean logging
-      })
+    const result = await downloadNpmPackage({
+      packageName: npmPackage,
+      workspaceRoot,
+    })
 
-      // Return path to installed plugin in node_modules
-      const pluginPath = path.join(workspaceRoot, 'node_modules', npmPackage)
-      return pluginPath
-    } catch (error) {
-      throw new NpmInstallationError(npmPackage, error instanceof Error ? error : undefined)
-    }
+    return result.packagePath
   }
 
   private getPackagePath(context: Launch77Context): string {