@launch77/cli 1.2.0 → 1.4.0

package/src/modules/plugin/commands/plugin-create.ts

@@ -0,0 +1,68 @@
+/* eslint-disable no-console */
+import * as path from 'path'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
+import { PluginCreateService } from '../services/plugin-create-service.js'
+
+export function pluginCreateCommand(): Command {
+  const command = new Command('plugin:create')
+    .argument('<plugin-name>', 'Name of the plugin to create (e.g., analytics)')
+    .option('-d, --description <description>', 'Plugin description')
+    .description('Create a new plugin from template')
+    .action(async (pluginName: string, options) => {
+      try {
+        console.log(chalk.blue(`\n🔌 Creating plugin: ${pluginName}\n`))
+
+        // Detect context
+        const context = await detectLaunch77Context(process.cwd())
+
+        // Create plugin service
+        const pluginCreateService = new PluginCreateService()
+
+        // Create plugin
+        const spinner = ora('Generating plugin structure...').start()
+        let result
+        try {
+          result = await pluginCreateService.createPlugin(
+            {
+              pluginName,
+              description: options.description,
+            },
+            context
+          )
+          spinner.succeed('Plugin structure generated')
+        } catch (error) {
+          spinner.fail('Failed to generate plugin structure')
+          throw error
+        }
+
+        // Success message
+        const relativePath = path.relative(process.cwd(), result.pluginPath)
+        const displayPath = relativePath.startsWith('..') ? result.pluginPath : relativePath
+        console.log(chalk.green(`\n✅ Plugin created successfully at ${displayPath}`))
+
+        // Next steps
+        console.log(chalk.white('\n' + '─'.repeat(60) + '\n'))
+        console.log(chalk.cyan('📋 Next Steps:\n'))
+        const cdPath = path.relative(process.cwd(), result.pluginPath)
+        console.log(chalk.gray('1. Navigate to your plugin directory:'))
+        console.log(chalk.cyan(`   cd ${cdPath}\n`))
+        console.log(chalk.gray('2. Implement your plugin logic in src/generator.ts\n'))
+        console.log(chalk.gray('3. Add any template files to templates/\n'))
+        console.log(chalk.gray('4. Build your plugin:'))
+        console.log(chalk.cyan('   npm run build\n'))
+        console.log(chalk.gray('5. Test your plugin:'))
+        console.log(chalk.cyan(`   launch77 plugin:install ${pluginName}\n`))
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        console.error(chalk.red('Error:'), message)
+        process.exit(1)
+      }
+    })
+
+  return command
+}

package/src/modules/plugin/commands/plugin-install.ts

@@ -1,48 +1,31 @@
 /* eslint-disable no-console */
 import chalk from 'chalk'
 import { Command } from 'commander'
-import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { PluginService } from '../services/plugin-svc.js'
 
 export function pluginInstallCommand(): Command {
   const command = new Command('plugin:install')
-    .argument('<plugin-name>', 'Name of the plugin to install (e.g., database)')
-    .description('Install a plugin to the current app')
+    .argument('<plugin-name>', 'Name of the plugin to install (e.g., release, @org/plugin-name)')
+    .description('Install a plugin to the current package')
     .action(async (pluginName: string) => {
       try {
-        console.log(chalk.blue(`\n🔌 Installing ${pluginName} plugin\n`))
-
         // Detect context
         const context = await detectLaunch77Context(process.cwd())
 
         // Create plugin service
         const pluginService = new PluginService()
 
-        // Install files
-        const filesSpinner = ora('Installing plugin files...').start()
-        try {
-          await pluginService.installPlugin({ pluginName }, context)
-          filesSpinner.succeed('Plugin files installed')
-        } catch (error) {
-          filesSpinner.fail('Failed to install plugin')
-          throw error
-        }
-
-        // Package.json update spinner
-        const pkgSpinner = ora('Updating package.json...').start()
-        pkgSpinner.succeed('package.json updated')
-
-        // Dependencies spinner
-        const installSpinner = ora('Installing dependencies...').start()
-        installSpinner.succeed('Dependencies installed')
+        // Install plugin with transparent logging
+        // The service handles all logging internally
+        await pluginService.installPlugin({ pluginName }, context, console.log)
 
-        // Success message (post-install hook handles custom messages)
-        console.log(chalk.green(`\n✅ Plugin '${pluginName}' installed successfully!\n`))
+        // Success message
+        console.log(chalk.green(`✅ Plugin '${pluginName}' installed successfully!\n`))
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
-        console.error(chalk.red('Error:'), message)
+        console.error(chalk.red('\nError:'), message)
         process.exit(1)
       }
     })

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

@@ -16,20 +16,71 @@ export class InvalidPluginContextError extends Error {
 
 /**
  * Factory function to create standardized InvalidPluginContextError
- * for when plugin:install is run outside of an app directory
+ * 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 an app directory.
+    `plugin:install must be run from within a package directory.
 
 Current location: ${currentLocation}
-Expected: apps/<app-name>/
+Expected: apps/<name>/, libraries/<name>/, plugins/<name>/, or app-templates/<name>/
 
-Navigate to an app directory:
+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(', ')}
 
-Or create an app first:
-  launch77 app:create api <app-name>`
+Allowed locations:
+${targetLocations.map((loc) => `  ${loc}`).join('\n')}`
   )
 }
 
@@ -42,3 +93,33 @@ export class PluginInstallationError extends Error {
     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'
+  }
+}

package/src/modules/plugin/index.ts

@@ -1,14 +1,16 @@
 // Services
 export { PluginService } from './services/plugin-svc.js'
+export { PluginCreateService } from './services/plugin-create-service.js'
 
 // Types
 export type { InstallPluginRequest, InstallPluginResult, PluginMetadata, HookResult } from './types/plugin-types.js'
 
 // Errors
-export { PluginNotFoundError, InvalidPluginContextError, PluginInstallationError } from './errors/plugin-errors.js'
+export { PluginNotFoundError, InvalidPluginContextError, PluginInstallationError, PluginResolutionError, NpmInstallationError } from './errors/plugin-errors.js'
 
 // Commands
 export { pluginInstallCommand } from './commands/plugin-install.js'
+export { pluginCreateCommand } from './commands/plugin-create.js'
 
 // Utilities
-export { getPluginPath, pluginExists, listAvailablePlugins } from './lib/plugin-registry.js'
+export { listAvailablePlugins } from './lib/plugin-registry.js'

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

@@ -1,55 +1,32 @@
 import * as path from 'path'
-import { fileURLToPath } from 'url'
 
 import fs from 'fs-extra'
 
 /**
- * Get the path to a plugin directory
- * Plugins are bundled with the CLI at dist/plugins/
+ * List all available plugins in the workspace
+ * Scans the workspace plugins/ directory for valid plugins
+ *
+ * @param workspaceRoot - The root directory of the Launch77 workspace
+ * @returns Array of plugin names found in the workspace
  */
-export function getPluginPath(pluginName: string): string {
-  const __filename = fileURLToPath(import.meta.url)
-  const __dirname = path.dirname(__filename)
+export async function listAvailablePlugins(workspaceRoot: string): Promise<string[]> {
+  const pluginsDir = path.join(workspaceRoot, 'plugins')
 
-  // From dist/modules/plugin/lib/ to dist/plugins/
-  const baseDir = path.join(__dirname, '../../../plugins')
-
-  return path.join(baseDir, pluginName)
-}
-
-/**
- * Check if a plugin exists
- * A plugin must have: dist/generator.js and plugin.json
- */
-export async function pluginExists(pluginName: string): Promise<boolean> {
-  const pluginPath = getPluginPath(pluginName)
-
-  const hasGenerator = await fs.pathExists(path.join(pluginPath, 'dist/generator.js'))
-  const hasPluginJson = await fs.pathExists(path.join(pluginPath, 'plugin.json'))
-
-  return hasGenerator && hasPluginJson
-}
-
-/**
- * List all available plugins
- */
-export async function listAvailablePlugins(): Promise<string[]> {
-  const __filename = fileURLToPath(import.meta.url)
-  const __dirname = path.dirname(__filename)
-
-  const baseDir = path.join(__dirname, '../../../plugins')
-
-  if (!(await fs.pathExists(baseDir))) {
+  if (!(await fs.pathExists(pluginsDir))) {
     return []
   }
 
-  const items = await fs.readdir(baseDir, { withFileTypes: true })
+  const items = await fs.readdir(pluginsDir, { withFileTypes: true })
   const plugins: string[] = []
 
   for (const item of items) {
     if (item.isDirectory()) {
       // Verify it's a valid plugin
-      if (await pluginExists(item.name)) {
+      const pluginPath = path.join(pluginsDir, item.name)
+      const hasPluginJson = await fs.pathExists(path.join(pluginPath, 'plugin.json'))
+      const hasGenerator = await fs.pathExists(path.join(pluginPath, 'dist/generator.js'))
+
+      if (hasPluginJson && hasGenerator) {
         plugins.push(item.name)
       }
     }

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',
+      })
+    })
+  })
+})