@launch77/cli 1.7.2 → 1.7.4

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

@@ -1,303 +0,0 @@
-import * as path from 'path'
-import * as fs from 'fs/promises'
-
-import chalk from 'chalk'
-import { execa } from 'execa'
-import fsExtra from 'fs-extra'
-import { readPluginMetadata } from '@launch77/plugin-runtime'
-
-import { downloadNpmPackage } from '../../../infrastructure/npm-package.js'
-import * as npm from '../../../infrastructure/npm.js'
-import { validateWorkspaceContext } from '../../../utils/launch77-validation.js'
-import { validateAppName } from '../../../utils/validation.js'
-import { PluginInstallationError, InvalidPluginContextError, createInvalidContextError, MissingPluginTargetsError, createInvalidTargetError, NpmInstallationError, PluginResolutionError, PluginDirectoryNotFoundError, InvalidPluginNameError } from '../errors/plugin-errors.js'
-import { PluginResolver } from '../lib/plugin-resolver.js'
-
-import type { Launch77Context, Launch77LocationType, Launch77PackageManifest, InstalledPluginMetadata, PluginMetadata } from '@launch77/plugin-runtime'
-import type { InstallPluginRequest, InstallPluginResult, DeletePluginRequest, DeletePluginResult } 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 {
-  private pluginResolver: PluginResolver
-
-  constructor() {
-    this.pluginResolver = new PluginResolver()
-  }
-
-  /**
-   * Validate that we're in a valid package directory and return the target type
-   */
-  private validateContext(context: Launch77Context): string {
-    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.')
-    return currentTarget
-  }
-
-  /**
-   * Validate plugin name, resolve its location, and download if needed
-   */
-  private async validateAndResolvePlugin(pluginName: string, workspaceRoot: string, logger: (message: string) => void): Promise<{ pluginPath: string; source: 'local' | 'npm'; npmPackage?: string; version: string }> {
-    logger(chalk.blue(`\n🔍 Resolving plugin "${pluginName}"...`))
-    logger(`  ├─ Validating plugin name...`)
-
-    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 this.pluginResolver.resolveLocation(pluginName, workspaceRoot)
-
-    let pluginPath: string
-    let version: string
-
-    if (resolution.source === 'local') {
-      logger(`  │  └─ ${chalk.green('✓')} Found local plugin`)
-      pluginPath = resolution.localPath!
-      version = resolution.version! // Local plugins always have version after verification
-    } else {
-      logger(`  │  └─ ${chalk.dim('Not found locally')}`)
-      logger(`  ├─ Resolving to npm package: ${chalk.cyan(resolution.npmPackage)}`)
-
-      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, workspaceRoot, logger)
-
-      // Read version from downloaded package
-      const packageJsonPath = path.join(pluginPath, 'package.json')
-      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
-      const packageJson = JSON.parse(packageJsonContent)
-      version = packageJson.version
-    }
-
-    logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
-
-    return {
-      pluginPath,
-      source: resolution.source,
-      npmPackage: resolution.npmPackage,
-      version,
-    }
-  }
-
-  /**
-   * Read plugin metadata and validate it supports the current target
-   */
-  private async validatePluginTargets(pluginPath: string, pluginName: string, currentTarget: string): Promise<PluginMetadata> {
-    const metadata = await readPluginMetadata(pluginPath)
-
-    if (!metadata.targets || metadata.targets.length === 0) {
-      throw new MissingPluginTargetsError(pluginName)
-    }
-
-    if (!metadata.targets.includes(currentTarget)) {
-      throw createInvalidTargetError(pluginName, currentTarget, metadata.targets)
-    }
-
-    return metadata
-  }
-
-  /**
-   * Check if plugin is already installed and return early-exit result if so
-   */
-  private async checkExistingInstallation(pluginName: string, packagePath: string, logger: (message: string) => void): Promise<InstallPluginResult | null> {
-    const existingInstallation = await this.isPluginInstalled(pluginName, packagePath)
-    if (existingInstallation) {
-      logger(chalk.yellow(`\nℹ️  Plugin '${pluginName}' is already installed in this package.\n`))
-      logger(`Package: ${chalk.cyan(existingInstallation.package)} (${existingInstallation.source})`)
-      logger(`Version: ${existingInstallation.version}`)
-      logger(`Installed: ${existingInstallation.installedAt}\n`)
-      logger(chalk.gray('To reinstall: Remove from package.json launch77.installedPlugins'))
-      logger(chalk.gray('(plugin:remove command coming soon)\n'))
-      return {
-        pluginName,
-        filesInstalled: false,
-        packageJsonUpdated: false,
-        dependenciesInstalled: false,
-      }
-    }
-    return null
-  }
-
-  /**
-   * Install a plugin to the current package
-   */
-  async installPlugin(request: InstallPluginRequest, context: Launch77Context, logger: (message: string) => void = console.log): Promise<InstallPluginResult> {
-    const { pluginName } = request
-
-    const currentTarget = this.validateContext(context)
-    const { pluginPath, source, npmPackage, version } = await this.validateAndResolvePlugin(pluginName, context.workspaceRoot, logger)
-    const metadata = await this.validatePluginTargets(pluginPath, pluginName, currentTarget)
-
-    const packagePath = this.getPackagePath(context)
-    const earlyExit = await this.checkExistingInstallation(pluginName, packagePath, logger)
-    if (earlyExit) return earlyExit
-
-    await this.runGenerator(pluginPath, packagePath, context)
-
-    const packageName = source === 'npm' ? npmPackage! : pluginName
-    await this.writePluginManifest(packagePath, {
-      pluginName,
-      packageName,
-      version,
-      source,
-    })
-
-    return {
-      pluginName,
-      filesInstalled: true,
-      packageJsonUpdated: true,
-      dependenciesInstalled: true,
-    }
-  }
-
-  /**
-   * 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)}...`)
-
-    const result = await downloadNpmPackage({
-      packageName: npmPackage,
-      workspaceRoot,
-    })
-
-    return result.packagePath
-  }
-
-  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')
-
-      const args = [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`]
-
-      await execa('node', args, {
-        cwd: pluginPath,
-        stdio: 'inherit',
-      })
-    } catch (error) {
-      throw new PluginInstallationError(`Generator failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined)
-    }
-  }
-
-  private async isPluginInstalled(pluginName: string, packagePath: string): Promise<InstalledPluginMetadata | null> {
-    try {
-      const packageJsonPath = path.join(packagePath, 'package.json')
-      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
-      const packageJson = JSON.parse(packageJsonContent)
-
-      const manifest = packageJson.launch77 as Launch77PackageManifest | undefined
-
-      if (manifest?.installedPlugins?.[pluginName]) {
-        return manifest.installedPlugins[pluginName]
-      }
-
-      return null
-    } catch (error) {
-      // If package.json doesn't exist or can't be read, assume not installed
-      return null
-    }
-  }
-
-  /**
-   * Write plugin installation metadata to the target package's package.json
-   */
-  private async writePluginManifest(packagePath: string, installationInfo: { pluginName: string; packageName: string; version: string; source: 'local' | 'npm' }): Promise<void> {
-    try {
-      const packageJsonPath = path.join(packagePath, 'package.json')
-      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
-      const packageJson = JSON.parse(packageJsonContent)
-
-      if (!packageJson.launch77) {
-        packageJson.launch77 = {}
-      }
-
-      if (!packageJson.launch77.installedPlugins) {
-        packageJson.launch77.installedPlugins = {}
-      }
-
-      const manifest = packageJson.launch77 as Launch77PackageManifest
-
-      manifest.installedPlugins![installationInfo.pluginName] = {
-        package: installationInfo.packageName,
-        version: installationInfo.version,
-        installedAt: new Date().toISOString(),
-        source: installationInfo.source,
-      }
-
-      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8')
-    } catch (error) {
-      throw new PluginInstallationError(`Failed to write plugin manifest: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined)
-    }
-  }
-
-  /**
-   * Delete a plugin from the workspace
-   */
-  async deletePlugin(request: DeletePluginRequest, context: Launch77Context): Promise<DeletePluginResult> {
-    const { pluginName } = request
-
-    // 1. Validate plugin name (reusing app name validation since format is the same)
-    const nameValidation = validateAppName(pluginName)
-    if (!nameValidation.valid) {
-      throw new InvalidPluginNameError(nameValidation.errorMessage || 'Invalid plugin name')
-    }
-
-    // 2. Validate workspace context
-    const contextValidation = validateWorkspaceContext(context)
-    if (!contextValidation.valid) {
-      throw new Error(contextValidation.errorMessage || 'Invalid workspace context')
-    }
-
-    // 3. Determine plugin path
-    const pluginPath = path.join(context.workspaceRoot, 'plugins', pluginName)
-
-    // 4. Check if plugin exists
-    if (!(await fsExtra.pathExists(pluginPath))) {
-      throw new PluginDirectoryNotFoundError(pluginName, pluginPath)
-    }
-
-    // 5. Delete the plugin directory
-    await fsExtra.remove(pluginPath)
-
-    // 6. Update dependencies
-    await npm.install(context.workspaceRoot)
-
-    return {
-      pluginName,
-    }
-  }
-}

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

@@ -1,29 +0,0 @@
-export interface InstallPluginRequest {
-  pluginName: string
-}
-
-export interface InstallPluginResult {
-  pluginName: string
-  filesInstalled: boolean
-  packageJsonUpdated: boolean
-  dependenciesInstalled: boolean
-}
-
-export interface PluginMetadata {
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  scripts?: Record<string, string>
-}
-
-export interface HookResult {
-  templateVariables?: Record<string, string>
-  hookContext?: Record<string, string>
-}
-
-export interface DeletePluginRequest {
-  pluginName: string
-}
-
-export interface DeletePluginResult {
-  pluginName: string
-}