@launch77/cli 1.4.3 → 1.5.0

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 () => {
@@ -113,19 +120,21 @@ describe('Plugin Resolver', () => {
       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, 'package.json'), JSON.stringify({ name: 'my-plugin', version: '0.0.1' }))
       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',
         resolvedName: 'my-plugin',
         localPath: pluginPath,
+        version: '0.0.1',
       })
     })
 
     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 +150,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 +165,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 +179,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 +189,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 +202,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 +212,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,41 @@
 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")
- *
- * 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
+ * Plugin resolver implementation
  *
- * @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'
+ * Resolves plugins from:
+ * - Local workspace plugins/ directory
+ * - npm packages with @launch77-shared/plugin- prefix
  */
-export function toNpmPackageName(name: string): string {
-  const trimmedName = name.trim()
-
-  // If already scoped, use as-is
-  if (trimmedName.startsWith('@')) {
-    return trimmedName
+export class PluginResolver extends PackageResolver {
+  protected getFolderName(): string {
+    return 'plugins'
   }
 
-  // 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,
-    }
+  protected getPackagePrefix(): string {
+    return '@launch77-shared/plugin-'
   }
 
-  // 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)
+  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) {
-      return {
-        source: 'local',
-        resolvedName: trimmedName,
-        localPath,
-      }
+    if (!hasPluginJson || !hasGenerator || !hasPackageJson) {
+      return false
     }
-  }
 
-  // Not found locally, resolve to npm package
-  const npmPackage = toNpmPackageName(trimmedName)
-
-  return {
-    source: 'npm',
-    resolvedName: trimmedName,
-    npmPackage,
+    // Verify package.json has a version field
+    try {
+      const packageJson = await fs.readJson(path.join(localPath, 'package.json'))
+      return !!packageJson.version
+    } catch {
+      return false
+    }
   }
 }

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

@@ -159,9 +159,9 @@ describe('PluginService', () => {
 
       const result = await (service as any).validatePluginTargets(pluginDir, 'test-plugin', 'app')
       expect(result).toEqual({
-        name: 'test-plugin',
-        version: '1.0.0',
         targets: ['app', 'library'],
+        pluginDependencies: undefined,
+        libraryDependencies: undefined,
       })
     })
 
@@ -175,8 +175,11 @@ describe('PluginService', () => {
       })
 
       const result = await (service as any).validatePluginTargets(pluginDir, 'multi-target-plugin', 'library')
-      expect(result.targets).toContain('library')
-      expect(result.targets).toHaveLength(4)
+      expect(result).toEqual({
+        targets: ['app', 'library', 'plugin', 'app-template'],
+        pluginDependencies: undefined,
+        libraryDependencies: undefined,
+      })
     })
 
     test('should handle plugin.json with optional fields (pluginDependencies, libraryDependencies)', async () => {
@@ -191,8 +194,11 @@ describe('PluginService', () => {
       })
 
       const result = await (service as any).validatePluginTargets(pluginDir, 'full-plugin', 'app')
-      expect(result.pluginDependencies).toEqual({ 'other-plugin': '^1.0.0' })
-      expect(result.libraryDependencies).toEqual({ react: '^18.0.0' })
+      expect(result).toEqual({
+        targets: ['app'],
+        pluginDependencies: { 'other-plugin': '^1.0.0' },
+        libraryDependencies: { react: '^18.0.0' },
+      })
     })
 
     // Error scenarios - test exact error messages

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
    */
@@ -43,29 +50,37 @@ export class PluginService {
   /**
    * 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 }> {
+  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 = 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
+    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`)
@@ -74,6 +89,7 @@ export class PluginService {
       pluginPath,
       source: resolution.source,
       npmPackage: resolution.npmPackage,
+      version,
     }
   }
 
@@ -123,7 +139,7 @@ export class PluginService {
     const { pluginName } = request
 
     const currentTarget = this.validateContext(context)
-    const { pluginPath, source, npmPackage } = await this.validateAndResolvePlugin(pluginName, context.workspaceRoot, logger)
+    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)
@@ -136,7 +152,7 @@ export class PluginService {
     await this.writePluginManifest(packagePath, {
       pluginName,
       packageName,
-      version: metadata.version,
+      version,
       source,
     })
 
@@ -154,19 +170,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 {

package/src/utils/validation.ts

@@ -2,7 +2,7 @@ import * as path from 'path'
 
 import chalk from 'chalk'
 
-import type { MonorepoContext } from './monorepo.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 
 /**
  * Validation result with helpful error messages
@@ -12,50 +12,22 @@ export interface ValidationResult {
   errorMessage?: string
 }
 
-/**
- * Validate that we're in a startup context (for create-app)
- */
-export function validateStartupContext(context: MonorepoContext): ValidationResult {
-  if (!context.isValid) {
-    return {
-      valid: false,
-      errorMessage: 'Must be run from within a Launch77 monorepo (could not find .launch-monorepo-root.md)',
-    }
-  }
-
-  if (context.location !== 'startup-root' && context.location !== 'startup-app') {
-    return {
-      valid: false,
-      errorMessage: `Command must be run from a startup directory.\n\n` + `${chalk.gray('Current location:')} ${context.location}\n` + `${chalk.gray('Expected:')} Within startups/<startup-name>/\n\n` + `${chalk.yellow('Navigate to a startup first:')}\n` + `  cd startups/<startup-name>/\n\n` + `${chalk.yellow('Or create a startup:')}\n` + `  launch77 create-startup <startup-name>`,
-    }
-  }
-
-  if (!context.appsDir) {
-    return {
-      valid: false,
-      errorMessage: `Could not determine apps directory for location: ${context.location}\n` + `This is a bug. Please report it.`,
-    }
-  }
-
-  return { valid: true }
-}
-
 /**
  * Validate that we're inside an app directory (for plugin:install)
  */
-export function validateAppContext(context: MonorepoContext): ValidationResult {
+export function validateAppContext(context: Launch77Context): ValidationResult {
   if (!context.isValid) {
     return {
       valid: false,
-      errorMessage: 'Must be run from within a Launch77 monorepo (could not find .launch-monorepo-root.md)',
+      errorMessage: 'Must be run from within a Launch77 workspace (could not find .launch77/workspace.json)',
     }
   }
 
-  // Must be inside an app, not just a startup
-  if (context.location !== 'startup-app') {
+  // Must be inside an app
+  if (context.locationType !== 'workspace-app') {
     return {
       valid: false,
-      errorMessage: `plugin:install must be run from within an app directory.\n\n` + `${chalk.gray('Current location:')} ${context.location}\n` + `${chalk.gray('Expected:')} startups/<startup-name>/apps/<app-name>/\n\n` + `${chalk.yellow('Navigate to an app directory:')}\n` + `  cd startups/<startup-name>/apps/<app-name>/\n\n` + `${chalk.yellow('Or create an app first:')}\n` + `  cd startups/<startup-name>/\n` + `  launch77 app:create api <app-name>`,
+      errorMessage: `plugin:install must be run from within an app directory.\n\n` + `${chalk.gray('Current location:')} ${context.locationType}\n` + `${chalk.gray('Expected:')} apps/<app-name>/\n\n` + `${chalk.yellow('Navigate to an app directory:')}\n` + `  cd apps/<app-name>/\n\n` + `${chalk.yellow('Or create an app first:')}\n` + `  launch77 app:create <template> <app-name>`,
     }
   }
 
@@ -73,16 +45,16 @@ export function validateAppContext(context: MonorepoContext): ValidationResult {
  * Get the app directory path
  * Returns null if not in an app context
  */
-export function getAppDirectory(context: MonorepoContext): string | null {
-  if (context.location !== 'startup-app') {
+export function getAppDirectory(context: Launch77Context): string | null {
+  if (context.locationType !== 'workspace-app') {
     return null
   }
 
-  if (!context.monorepoRoot || !context.startupName || !context.appName) {
+  if (!context.workspaceRoot || !context.appName) {
     return null
   }
 
-  return path.join(context.monorepoRoot, 'startups', context.startupName, 'apps', context.appName)
+  return path.join(context.workspaceRoot, 'apps', context.appName)
 }
 
 /**

package/templates/plugin/package.json.hbs

@@ -1,6 +1,6 @@
 {
   "name": "@{{workspaceName}}/plugin-{{pluginName}}",
-  "version": "1.0.0",
+  "version": "0.0.1",
   "description": "{{description}}",
   "license": "UNLICENSED",
   "private": true,

package/templates/plugin/plugin.json.hbs

@@ -1,7 +1,5 @@
 {
-  "name": "{{pluginName}}",
-  "version": "1.0.0",
-  "description": "{{description}}",
+  "targets": ["app", "library"],
   "pluginDependencies": {},
   "libraryDependencies": {}
 }

package/dist/modules/app/commands/generate-manifest.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function generateManifestCommand(): Command;
-//# sourceMappingURL=generate-manifest.d.ts.map

package/dist/modules/app/commands/generate-manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-manifest.d.ts","sourceRoot":"","sources":["../../../../src/modules/app/commands/generate-manifest.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAQnC,wBAAgB,uBAAuB,IAAI,OAAO,CA8DjD"}