@launch77/cli 1.3.0 → 1.4.0

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

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import * as path from 'path'
+import * as os from 'os'
+import fs from 'fs-extra'
+
+import { validatePluginInput, toNpmPackageName, resolvePluginLocation } from './plugin-resolver.js'
+
+describe('Plugin Resolver', () => {
+  describe('validatePluginInput', () => {
+    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 })
+    })
+
+    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 })
+    })
+
+    it('should reject empty names', () => {
+      const result = validatePluginInput('')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    it('should reject whitespace-only names', () => {
+      const result = validatePluginInput('   ')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    it('should reject invalid scoped packages', () => {
+      const result1 = validatePluginInput('@invalid')
+      expect(result1.isValid).toBe(false)
+      expect(result1.error).toBeDefined()
+
+      const result2 = validatePluginInput('@/package')
+      expect(result2.isValid).toBe(false)
+      expect(result2.error).toBeDefined()
+
+      const result3 = validatePluginInput('@org/')
+      expect(result3.isValid).toBe(false)
+      expect(result3.error).toBeDefined()
+    })
+
+    it('should reject names with uppercase letters', () => {
+      const result = validatePluginInput('MyPlugin')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('lowercase')
+    })
+
+    it('should reject names starting with numbers', () => {
+      const result = validatePluginInput('123plugin')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    it('should reject names with special characters', () => {
+      const result1 = validatePluginInput('plugin_name')
+      expect(result1.isValid).toBe(false)
+
+      const result2 = validatePluginInput('plugin.name')
+      expect(result2.isValid).toBe(false)
+
+      const result3 = validatePluginInput('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 })
+    })
+  })
+
+  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')
+    })
+
+    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')
+    })
+
+    it('should trim whitespace', () => {
+      expect(toNpmPackageName('  release  ')).toBe('@launch77-shared/plugin-release')
+      expect(toNpmPackageName('  @ibm/analytics  ')).toBe('@ibm/analytics')
+    })
+  })
+
+  describe('resolvePluginLocation', () => {
+    let tempDir: string
+
+    beforeEach(async () => {
+      // Create a temporary workspace directory
+      tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'plugin-resolver-test-'))
+      await fs.ensureDir(path.join(tempDir, 'plugins'))
+    })
+
+    afterEach(async () => {
+      // Clean up
+      await fs.remove(tempDir)
+    })
+
+    it('should resolve local plugins first', async () => {
+      // Create a valid local plugin
+      const pluginPath = path.join(tempDir, 'plugins', 'my-plugin')
+      await fs.ensureDir(pluginPath)
+      await fs.ensureDir(path.join(pluginPath, 'dist'))
+      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)
+
+      expect(result).toEqual({
+        source: 'local',
+        resolvedName: 'my-plugin',
+        localPath: pluginPath,
+      })
+    })
+
+    it('should resolve to npm if local plugin does not exist', async () => {
+      const result = await resolvePluginLocation('release', tempDir)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: 'release',
+        npmPackage: '@launch77-shared/plugin-release',
+      })
+    })
+
+    it('should resolve to npm if local plugin is incomplete (missing plugin.json)', async () => {
+      // Create incomplete local plugin (no plugin.json)
+      const pluginPath = path.join(tempDir, 'plugins', 'incomplete')
+      await fs.ensureDir(pluginPath)
+      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)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: 'incomplete',
+        npmPackage: '@launch77-shared/plugin-incomplete',
+      })
+    })
+
+    it('should resolve to npm if local plugin is incomplete (missing generator.js)', async () => {
+      // Create incomplete local plugin (no generator.js)
+      const pluginPath = path.join(tempDir, 'plugins', 'incomplete')
+      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)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: 'incomplete',
+        npmPackage: '@launch77-shared/plugin-incomplete',
+      })
+    })
+
+    it('should always resolve scoped packages to npm', async () => {
+      // Even if a directory exists locally, scoped names go to npm
+      const pluginPath = path.join(tempDir, 'plugins', '@ibm')
+      await fs.ensureDir(pluginPath)
+
+      const result = await resolvePluginLocation('@ibm/analytics', tempDir)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: '@ibm/analytics',
+        npmPackage: '@ibm/analytics',
+      })
+    })
+
+    it('should resolve scoped @launch77-shared packages to npm', async () => {
+      const result = await resolvePluginLocation('@launch77-shared/plugin-release', tempDir)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: '@launch77-shared/plugin-release',
+        npmPackage: '@launch77-shared/plugin-release',
+      })
+    })
+
+    it('should handle plugins directory not existing', async () => {
+      // Remove plugins directory
+      await fs.remove(path.join(tempDir, 'plugins'))
+
+      const result = await resolvePluginLocation('release', tempDir)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: 'release',
+        npmPackage: '@launch77-shared/plugin-release',
+      })
+    })
+
+    it('should trim whitespace from plugin names', async () => {
+      const result = await resolvePluginLocation('  release  ', tempDir)
+
+      expect(result).toEqual({
+        source: 'npm',
+        resolvedName: 'release',
+        npmPackage: '@launch77-shared/plugin-release',
+      })
+    })
+  })
+})

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

@@ -0,0 +1,160 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+import { parsePluginName, isValidNpmPackageName } from '@launch77/plugin-runtime'
+
+import type { ValidationResult } from '@launch77/plugin-runtime'
+
+/**
+ * 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")
+ *
+ * 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: '...' }
+ */
+export function validatePluginInput(name: string): ValidationResult {
+  if (!name || name.trim().length === 0) {
+    return {
+      isValid: false,
+      error: 'Plugin name cannot be empty',
+    }
+  }
+
+  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,
+    }
+  }
+
+  // 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) {
+    // 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,
+  }
+}

package/src/modules/plugin/services/plugin-create-service.ts

@@ -0,0 +1,69 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+
+import { validatePluginName } from '@launch77/plugin-runtime'
+import { processTemplate, getPluginTemplatePath } from '../../../infrastructure/template.js'
+import { toPascalCase } from '../../../utils/string.js'
+
+import type { Launch77Context } from '@launch77/plugin-runtime'
+
+export interface CreatePluginRequest {
+  pluginName: string
+  description?: string
+}
+
+export interface CreatePluginResult {
+  pluginName: string
+  pluginPath: string
+}
+
+export class PluginCreateService {
+  /**
+   * Create a new plugin from template
+   */
+  async createPlugin(request: CreatePluginRequest, context: Launch77Context): Promise<CreatePluginResult> {
+    const { pluginName, description } = request
+
+    // 1. Validate plugin name
+    const nameValidation = validatePluginName(pluginName)
+    if (!nameValidation.isValid) {
+      throw new Error(nameValidation.error || 'Invalid plugin name')
+    }
+
+    // 2. Validate workspace context
+    if (!context.isValid) {
+      throw new Error('Must be run from within a Launch77 workspace')
+    }
+
+    // 3. Determine plugin path
+    const pluginPath = path.join(context.workspaceRoot, 'plugins', pluginName)
+
+    // 4. Check if plugin already exists
+    if (await fs.pathExists(pluginPath)) {
+      throw new Error(`Plugin '${pluginName}' already exists at ${pluginPath}`)
+    }
+
+    // 5. Get plugin template path
+    const templatePath = getPluginTemplatePath('plugin')
+
+    // 6. Check if template exists
+    if (!(await fs.pathExists(templatePath))) {
+      throw new Error(`Plugin template not found at ${templatePath}`)
+    }
+
+    // 7. Process template with context
+    await processTemplate(templatePath, pluginPath, {
+      appName: pluginName, // Required by TemplateContext but not used for plugin templates
+      pluginName,
+      pluginNamePascal: toPascalCase(pluginName),
+      workspaceName: context.workspaceName,
+      description: description || `Launch77 plugin for ${pluginName}`,
+    })
+
+    return {
+      pluginName,
+      pluginPath,
+    }
+  }
+}

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

@@ -1,34 +1,90 @@
 import * as path from 'path'
 
+import chalk from 'chalk'
 import { execa } from 'execa'
+import { readPluginMetadata } from '@launch77/plugin-runtime'
 
-import { PluginInstallationError, PluginNotFoundError, InvalidPluginContextError, createInvalidContextError } from '../errors/plugin-errors.js'
-import { pluginExists, getPluginPath } from '../lib/plugin-registry.js'
+import { PluginInstallationError, InvalidPluginContextError, createInvalidContextError, MissingPluginTargetsError, createInvalidTargetError, NpmInstallationError, PluginResolutionError } from '../errors/plugin-errors.js'
+import { validatePluginInput, resolvePluginLocation } from '../lib/plugin-resolver.js'
 
-import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { Launch77Context, Launch77LocationType } from '@launch77/plugin-runtime'
 import type { InstallPluginRequest, InstallPluginResult } from '../types/plugin-types.js'
 
+/**
+ * Map location type to target string
+ */
+function locationTypeToTarget(locationType: Launch77LocationType): string | null {
+  switch (locationType) {
+    case 'workspace-app':
+      return 'app'
+    case 'workspace-library':
+      return 'library'
+    case 'workspace-plugin':
+      return 'plugin'
+    case 'workspace-app-template':
+      return 'app-template'
+    default:
+      return null
+  }
+}
+
 export class PluginService {
   /**
-   * Install a plugin to the current app
+   * Install a plugin to the current package
    */
-  async installPlugin(request: InstallPluginRequest, context: Launch77Context): Promise<InstallPluginResult> {
+  async installPlugin(request: InstallPluginRequest, context: Launch77Context, logger: (message: string) => void = console.log): Promise<InstallPluginResult> {
     const { pluginName } = request
 
-    // Validate context - must be in app directory
-    if (context.locationType !== 'workspace-app') throw createInvalidContextError(context.locationType)
-    if (!context.appName) throw new InvalidPluginContextError('Could not determine app name. This is a bug. Please report it.')
+    // Must be in a package directory (app, library, plugin, or app-template)
+    const currentTarget = locationTypeToTarget(context.locationType)
+    if (!currentTarget) throw createInvalidContextError(context.locationType)
+    if (!context.appName) throw new InvalidPluginContextError('Could not determine package name. This is a bug. Please report it.')
+
+    // Step 1: Validate plugin input
+    logger(chalk.blue(`\n🔍 Resolving plugin "${pluginName}"...`))
+    logger(`  ├─ Validating plugin name...`)
+
+    const validation = validatePluginInput(pluginName)
+    if (!validation.isValid) {
+      throw new PluginResolutionError(pluginName, validation.error || 'Invalid plugin name')
+    }
+    logger(`  │  └─ ${chalk.green('✓')} Valid plugin name`)
+
+    // Step 2: Resolve plugin location
+    logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
+    const resolution = await resolvePluginLocation(pluginName, context.workspaceRoot)
 
-    // Get app directory path
-    const appPath = path.join(context.appsDir, context.appName)
+    let pluginPath: string
+
+    if (resolution.source === 'local') {
+      logger(`  │  └─ ${chalk.green('✓')} Found local plugin`)
+      pluginPath = resolution.localPath!
+    } else {
+      logger(`  │  └─ ${chalk.dim('Not found locally')}`)
+      logger(`  ├─ Resolving to npm package: ${chalk.cyan(resolution.npmPackage)}`)
+
+      // Download npm plugin
+      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, context.workspaceRoot, logger)
+    }
+
+    logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
+
+    // Step 3: Read plugin metadata and validate targets
+    const metadata = await readPluginMetadata(pluginPath)
+
+    if (!metadata.targets || metadata.targets.length === 0) {
+      throw new MissingPluginTargetsError(pluginName)
+    }
 
-    // Check if plugin exists
-    if (!(await pluginExists(pluginName))) throw new PluginNotFoundError(pluginName)
+    if (!metadata.targets.includes(currentTarget)) {
+      throw createInvalidTargetError(pluginName, currentTarget, metadata.targets)
+    }
 
-    const pluginPath = getPluginPath(pluginName)
+    // Step 4: Get package directory path
+    const packagePath = this.getPackagePath(context)
 
-    // Run generator
-    await this.runGenerator(pluginPath, appPath, context)
+    // Step 5: Run generator
+    await this.runGenerator(pluginPath, packagePath, context)
 
     return {
       pluginName,
@@ -38,6 +94,43 @@ export class PluginService {
     }
   }
 
+  /**
+   * Download and install an npm plugin package
+   */
+  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
+      })
+
+      // 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)
+    }
+  }
+
+  private getPackagePath(context: Launch77Context): string {
+    // Determine the base directory based on location type
+    switch (context.locationType) {
+      case 'workspace-app':
+        return path.join(context.appsDir, context.appName!)
+      case 'workspace-library':
+        return path.join(context.workspaceRoot, 'libraries', context.appName!)
+      case 'workspace-plugin':
+        return path.join(context.workspaceRoot, 'plugins', context.appName!)
+      case 'workspace-app-template':
+        return path.join(context.workspaceRoot, 'app-templates', context.appName!)
+      default:
+        throw new InvalidPluginContextError(`Cannot install plugin from ${context.locationType}`)
+    }
+  }
+
   private async runGenerator(pluginPath: string, appPath: string, context: Launch77Context): Promise<void> {
     try {
       const generatorPath = path.join(pluginPath, 'dist/generator.js')