@launch77/cli 1.7.2 → 1.7.4

package/src/infrastructure/package-resolver.ts

@@ -1,223 +0,0 @@
-import * as path from 'path'
-
-import { parsePluginName, isValidNpmPackageName } from '@launch77/plugin-runtime'
-import fs from 'fs-extra'
-
-import type { ValidationResult } from '@launch77/plugin-runtime'
-
-/**
- * Base interface for package resolution results
- */
-export interface PackageResolution {
-  /** The source of the package */
-  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
-  /** The version from package.json (required for local packages, undefined for npm until installed) */
-  version?: string
-}
-
-/**
- * Abstract base class for resolving Launch77 packages
- *
- * Provides generic resolution logic for finding packages in:
- * 1. Local workspace directory (e.g., plugins/, app-templates/)
- * 2. npm packages with configured prefix (e.g., @launch77-shared/plugin-*, @launch77-shared/app-template-*)
- *
- * Concrete implementations must provide:
- * - Folder name for local resolution
- * - Package prefix for npm resolution
- * - Verification logic to validate local packages
- */
-export abstract class PackageResolver {
-  /**
-   * Get the local folder name where packages of this type are stored
-   * @example 'plugins' or 'app-templates'
-   */
-  protected abstract getFolderName(): string
-
-  /**
-   * Get the npm package prefix for unscoped packages
-   * @example '@launch77-shared/plugin-' or '@launch77-shared/app-template-'
-   */
-  protected abstract getPackagePrefix(): string
-
-  /**
-   * Verify that a local package is valid and complete
-   * @param localPath - The local directory path to verify
-   * @returns true if the package is valid, false otherwise
-   */
-  protected abstract verify(localPath: string): Promise<boolean>
-
-  /**
-   * Validate package input name
-   *
-   * Accepts:
-   * - Unscoped names (e.g., "release", "my-package")
-   * - Scoped npm packages (e.g., "@ibm/package-name")
-   *
-   * Rejects:
-   * - Invalid formats
-   * - Empty strings
-   * - Names with invalid characters
-   *
-   * @param name - The package name to validate
-   * @returns ValidationResult with isValid and optional error message
-   *
-   * @example
-   * validateInput('release') // { isValid: true }
-   * validateInput('@ibm/analytics') // { isValid: true }
-   * validateInput('@invalid') // { isValid: false, error: '...' }
-   */
-  validateInput(name: string): ValidationResult {
-    if (!name || name.trim().length === 0) {
-      return {
-        isValid: false,
-        error: 'Package name cannot be empty',
-      }
-    }
-
-    const trimmedName = name.trim()
-
-    // Parse the name to determine type and validate
-    //TODO: move/rename parsePluginName() to parsePackageName()
-    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 package name to an npm package name
-   *
-   * Rules:
-   * - Unscoped names: prefix with configured package prefix
-   * - Scoped names: use as-is
-   *
-   * @param name - The package name (must be validated first)
-   * @returns The npm package name
-   *
-   * @example
-   * toNpmPackageName('release') // '@launch77-shared/plugin-release' (for PluginResolver)
-   * toNpmPackageName('@ibm/analytics') // '@ibm/analytics'
-   */
-  toNpmPackageName(name: string): string {
-    const trimmedName = name.trim()
-
-    // If already scoped, use as-is
-    if (trimmedName.startsWith('@')) {
-      return trimmedName
-    }
-
-    // Otherwise, convert using configured prefix
-    return `${this.getPackagePrefix()}${trimmedName}`
-  }
-
-  /**
-   * Read version from package.json
-   * @param packagePath - The path to the package directory
-   * @returns The version string from package.json
-   * @throws If package.json doesn't exist, can't be read, or is missing the version field
-   */
-  private async readVersion(packagePath: string): Promise<string> {
-    const packageJsonPath = path.join(packagePath, 'package.json')
-    try {
-      const packageJson = await fs.readJson(packageJsonPath)
-      if (!packageJson.version) {
-        throw new Error(`Invalid package structure: package.json at ${packagePath} is missing required version field. ` + `All Launch77 packages must include a valid package.json with a version field.`)
-      }
-      return packageJson.version
-    } catch (error) {
-      // Re-throw our own error messages
-      if (error instanceof Error && error.message.includes('Invalid package structure')) {
-        throw error
-      }
-      // File not found or invalid JSON
-      throw new Error(`Invalid package structure: package.json not found or invalid at ${packagePath}. ` + `All Launch77 packages must include a valid package.json with a version field.`)
-    }
-  }
-
-  /**
-   * Resolve package location from name
-   *
-   * Resolution order:
-   * 1. Check local workspace directory (configured by getFolderName())
-   * 2. Verify local package is valid (using verify())
-   * 3. Fall back to npm package name (with configured prefix)
-   * 4. Read version from package.json (if available)
-   *
-   * @param name - The package name to resolve
-   * @param workspaceRoot - The workspace root directory
-   * @returns PackageResolution with source, resolved location, and version
-   *
-   * @example
-   * // Local package found
-   * await resolveLocation('my-package', '/workspace')
-   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package', version: '1.0.0' }
-   *
-   * // Not found locally, resolve to npm
-   * await resolveLocation('release', '/workspace')
-   * // { source: 'npm', resolvedName: 'release', npmPackage: '@launch77-shared/plugin-release' }
-   *
-   * // Scoped package always resolves to npm
-   * await resolveLocation('@ibm/analytics', '/workspace')
-   * // { source: 'npm', resolvedName: '@ibm/analytics', npmPackage: '@ibm/analytics' }
-   */
-  async resolveLocation(name: string, workspaceRoot: string): Promise<PackageResolution> {
-    const trimmedName = name.trim()
-    const parsed = parsePluginName(trimmedName)
-
-    // If scoped, always use npm (local packages are never scoped)
-    if (parsed.type === 'scoped') {
-      return {
-        source: 'npm',
-        resolvedName: trimmedName,
-        npmPackage: trimmedName,
-      }
-    }
-
-    // Check local workspace directory
-    const localPath = path.join(workspaceRoot, this.getFolderName(), trimmedName)
-    const localExists = await fs.pathExists(localPath)
-
-    if (localExists) {
-      // Verify it's a valid package
-      const isValid = await this.verify(localPath)
-
-      if (isValid) {
-        const version = await this.readVersion(localPath)
-        return {
-          source: 'local',
-          resolvedName: trimmedName,
-          localPath,
-          version,
-        }
-      }
-    }
-
-    // Not found locally or invalid, resolve to npm package
-    const npmPackage = this.toNpmPackageName(trimmedName)
-
-    return {
-      source: 'npm',
-      resolvedName: trimmedName,
-      npmPackage,
-    }
-  }
-}

package/src/modules/plugin/errors/plugin-errors.ts

@@ -1,145 +0,0 @@
-export class PluginNotFoundError extends Error {
-  constructor(pluginName: string) {
-    super(`Plugin '${pluginName}' not found.
-
-Run 'launch77 plugin:list' to see available plugins.`)
-    this.name = 'PluginNotFoundError'
-  }
-}
-
-export class InvalidPluginContextError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidPluginContextError'
-  }
-}
-
-/**
- * Factory function to create standardized InvalidPluginContextError
- * for when plugin:install is run outside of a package directory
- */
-export function createInvalidContextError(currentLocation: string): InvalidPluginContextError {
-  return new InvalidPluginContextError(
-    `plugin:install must be run from within a package directory.
-
-Current location: ${currentLocation}
-Expected: apps/<name>/, libraries/<name>/, plugins/<name>/, or app-templates/<name>/
-
-Navigate to a package directory:
-  cd apps/<app-name>/
-  cd libraries/<lib-name>/
-  cd plugins/<plugin-name>/
-  cd app-templates/<template-name>/`
-  )
-}
-
-/**
- * Error when plugin.json is missing the required 'targets' field
- */
-export class MissingPluginTargetsError extends Error {
-  constructor(pluginName: string) {
-    super(`Plugin '${pluginName}' is missing the required 'targets' field in plugin.json.
-
-The plugin.json file must include a 'targets' array specifying which package types
-the plugin can be installed into.
-
-Example plugin.json:
-{
-  "name": "${pluginName}",
-  "version": "1.0.0",
-  "targets": ["app", "library", "plugin", "app-template"],
-  "pluginDependencies": {},
-  "libraryDependencies": {}
-}`)
-    this.name = 'MissingPluginTargetsError'
-  }
-}
-
-/**
- * Factory function to create error when plugin targets don't match current location
- */
-export function createInvalidTargetError(pluginName: string, currentTarget: string, allowedTargets: string[]): InvalidPluginContextError {
-  const targetLocations = allowedTargets.map((target) => {
-    switch (target) {
-      case 'app':
-        return 'apps/<name>/'
-      case 'library':
-        return 'libraries/<name>/'
-      case 'plugin':
-        return 'plugins/<name>/'
-      case 'app-template':
-        return 'app-templates/<name>/'
-      default:
-        return target
-    }
-  })
-
-  return new InvalidPluginContextError(
-    `Plugin '${pluginName}' cannot be installed in a '${currentTarget}' package.
-
-This plugin can only be installed in: ${allowedTargets.join(', ')}
-
-Allowed locations:
-${targetLocations.map((loc) => `  ${loc}`).join('\n')}`
-  )
-}
-
-export class PluginInstallationError extends Error {
-  constructor(
-    message: string,
-    public readonly cause?: Error
-  ) {
-    super(message)
-    this.name = 'PluginInstallationError'
-  }
-}
-
-/**
- * Error when plugin resolution fails
- */
-export class PluginResolutionError extends Error {
-  constructor(pluginName: string, reason: string) {
-    super(`Failed to resolve plugin '${pluginName}': ${reason}`)
-    this.name = 'PluginResolutionError'
-  }
-}
-
-/**
- * Error when npm package installation fails
- */
-export class NpmInstallationError extends Error {
-  constructor(
-    packageName: string,
-    public readonly cause?: Error
-  ) {
-    super(`Failed to install npm package '${packageName}'.
-
-Please check:
-- Your internet connection
-- npm registry access (https://registry.npmjs.org)
-- Package exists: https://www.npmjs.com/package/${packageName}
-
-${cause ? `\nOriginal error: ${cause.message}` : ''}`)
-    this.name = 'NpmInstallationError'
-  }
-}
-
-/**
- * Error when plugin directory is not found for deletion
- */
-export class PluginDirectoryNotFoundError extends Error {
-  constructor(pluginName: string, expectedPath: string) {
-    super(`Plugin '${pluginName}' does not exist.\n\n` + `Expected location: ${expectedPath}\n\n` + `Available plugins:\n` + `  cd plugins/\n` + `  ls`)
-    this.name = 'PluginDirectoryNotFoundError'
-  }
-}
-
-/**
- * Error when plugin name validation fails
- */
-export class InvalidPluginNameError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidPluginNameError'
-  }
-}

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

@@ -1,41 +0,0 @@
-import * as path from 'path'
-
-import fs from 'fs-extra'
-
-import { PackageResolver } from '../../../infrastructure/package-resolver.js'
-
-/**
- * Plugin resolver implementation
- *
- * Resolves plugins from:
- * - Local workspace plugins/ directory
- * - npm packages with @launch77-shared/plugin- prefix
- */
-export class PluginResolver extends PackageResolver {
-  protected getFolderName(): string {
-    return 'plugins'
-  }
-
-  protected getPackagePrefix(): string {
-    return '@launch77-shared/plugin-'
-  }
-
-  protected async verify(localPath: string): Promise<boolean> {
-    // Verify it's a valid plugin (has plugin.json, dist/generator.js, and package.json with version)
-    const hasPluginJson = await fs.pathExists(path.join(localPath, 'plugin.json'))
-    const hasGenerator = await fs.pathExists(path.join(localPath, 'dist/generator.js'))
-    const hasPackageJson = await fs.pathExists(path.join(localPath, 'package.json'))
-
-    if (!hasPluginJson || !hasGenerator || !hasPackageJson) {
-      return false
-    }
-
-    // Verify package.json has a version field
-    try {
-      const packageJson = await fs.readJson(path.join(localPath, 'package.json'))
-      return !!packageJson.version
-    } catch {
-      return false
-    }
-  }
-}