@launch77/cli 1.3.0 → 1.4.1

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

@@ -1,34 +1,144 @@
 import * as path from 'path'
+import * as fs from 'fs/promises'
 
+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, Launch77PackageManifest, InstalledPluginMetadata, PluginMetadata } 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
+   * Validate that we're in a valid package directory and return the target type
    */
-  async installPlugin(request: InstallPluginRequest, context: Launch77Context): Promise<InstallPluginResult> {
-    const { pluginName } = request
+  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 }> {
+    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`)
+
+    logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
+    const resolution = await resolvePluginLocation(pluginName, workspaceRoot)
+
+    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)}`)
+
+      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, workspaceRoot, logger)
+    }
+
+    logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
+
+    return {
+      pluginPath,
+      source: resolution.source,
+      npmPackage: resolution.npmPackage,
+    }
+  }
+
+  /**
+   * 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)
+    }
 
-    // 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.')
+    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
 
-    // Get app directory path
-    const appPath = path.join(context.appsDir, context.appName)
+    const currentTarget = this.validateContext(context)
+    const { pluginPath, source, npmPackage } = await this.validateAndResolvePlugin(pluginName, context.workspaceRoot, logger)
+    const metadata = await this.validatePluginTargets(pluginPath, pluginName, currentTarget)
 
-    // Check if plugin exists
-    if (!(await pluginExists(pluginName))) throw new PluginNotFoundError(pluginName)
+    const packagePath = this.getPackagePath(context)
+    const earlyExit = await this.checkExistingInstallation(pluginName, packagePath, logger)
+    if (earlyExit) return earlyExit
 
-    const pluginPath = getPluginPath(pluginName)
+    await this.runGenerator(pluginPath, packagePath, context)
 
-    // Run generator
-    await this.runGenerator(pluginPath, appPath, context)
+    const packageName = source === 'npm' ? npmPackage! : pluginName
+    await this.writePluginManifest(packagePath, {
+      pluginName,
+      packageName,
+      version: metadata.version,
+      source,
+    })
 
     return {
       pluginName,
@@ -38,11 +148,50 @@ 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')
 
-      await execa('node', [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`], {
+      const args = [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`]
+
+      await execa('node', args, {
         cwd: pluginPath,
         stdio: 'inherit',
       })
@@ -50,4 +199,55 @@ export class PluginService {
       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)
+    }
+  }
 }

package/src/modules/release/commands/release-init.ts

@@ -0,0 +1,102 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+import ora from 'ora'
+
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
+import { GitService, GitHubService, GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError, GitHubNotConnectedError } from '../../git/index.js'
+import { ReleaseService } from '../services/release-service.js'
+import { ChangesetNotInitializedError } from '../errors/release-errors.js'
+
+export function releaseInitCommand(): Command {
+  return new Command('release:init').description('Initialize complete release workflow setup').action(async () => {
+    console.log(chalk.blue('\n🚀 Initializing release workflow...\n'))
+
+    const cwd = process.cwd()
+    const gitService = new GitService()
+    const githubService = new GitHubService()
+    const releaseService = new ReleaseService(githubService)
+
+    try {
+      // 1. Verify we're in a workspace root
+      const context = await detectLaunch77Context(cwd)
+      if (!context.isValid || context.locationType !== 'workspace-root') {
+        throw new NotInWorkspaceError(cwd)
+      }
+
+      // 2. Verify prerequisites (GitHub CLI installed and authenticated)
+      const spinner = ora('Checking prerequisites...').start()
+      await githubService.verifyPrerequisites()
+      spinner.succeed('Prerequisites verified')
+
+      // 3. Ensure connected to GitHub
+      try {
+        await gitService.ensureConnectedToGitHub(context.workspaceRoot)
+      } catch (error) {
+        if (error instanceof GitHubNotConnectedError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray(`   Connect to GitHub first: ${chalk.cyan('launch77 git:connect')}\n`))
+          process.exit(1)
+        }
+        throw error
+      }
+
+      // 4. Get repository information
+      const repoSpinner = ora('Detecting repository...').start()
+      const { owner, repo } = await githubService.getCurrentRepository(context.workspaceRoot)
+      repoSpinner.succeed(`Repository: ${owner}/${repo}`)
+
+      // 5. Fix changeset config access setting
+      console.log(chalk.cyan('\n📝 Configuring changesets...\n'))
+      try {
+        const changesetSpinner = ora('Checking changeset configuration...').start()
+        const wasChanged = await releaseService.fixChangesetAccess(context.workspaceRoot)
+
+        if (wasChanged) {
+          changesetSpinner.succeed('Updated .changeset/config.json access to "public"')
+        } else {
+          changesetSpinner.succeed('Changeset already configured correctly')
+        }
+      } catch (error) {
+        if (error instanceof ChangesetNotInitializedError) {
+          console.error(chalk.red(`\n❌ ${error.message}\n`))
+          console.log(chalk.gray('   Changesets should be initialized during workspace creation.'))
+          console.log(chalk.gray(`   Run manually: ${chalk.cyan('npx changeset init')}\n`))
+          process.exit(1)
+        }
+        throw error
+      }
+
+      // 6. Setup RELEASE_TOKEN
+      releaseService.explainReleaseToken()
+      const token = await releaseService.promptForReleaseToken()
+      await releaseService.setupReleaseToken(owner, repo, token)
+
+      // 7. Guide npm Trusted Publishing setup
+      releaseService.explainNpmTrustedPublishing()
+
+      // 8. Show success summary
+      releaseService.showSuccessSummary()
+    } catch (error) {
+      if (error instanceof GitHubCLINotInstalledError) {
+        console.error(chalk.red(`\n❌ ${error.message}\n`))
+        console.log(chalk.gray(`   Install with: ${chalk.cyan('brew install gh')}\n`))
+        console.log(chalk.gray(`   Or visit: ${chalk.cyan('https://cli.github.com/')}\n`))
+        process.exit(1)
+      }
+
+      if (error instanceof GitHubNotAuthenticatedError) {
+        console.error(chalk.red(`\n❌ ${error.message}\n`))
+        console.log(chalk.gray(`   Authenticate with: ${chalk.cyan('gh auth login')}\n`))
+        process.exit(1)
+      }
+
+      if (error instanceof NotInWorkspaceError) {
+        console.error(chalk.red(`\n❌ ${error.message}\n`))
+        console.log(chalk.gray(`   This command must be run from a Launch77 workspace root directory\n`))
+        process.exit(1)
+      }
+
+      throw error
+    }
+  })
+}

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

@@ -0,0 +1,13 @@
+export class InvalidReleaseTokenError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InvalidReleaseTokenError'
+  }
+}
+
+export class ChangesetNotInitializedError extends Error {
+  constructor() {
+    super('Changesets are not initialized in this workspace')
+    this.name = 'ChangesetNotInitializedError'
+  }
+}

package/src/modules/release/index.ts

@@ -0,0 +1,8 @@
+// Services
+export { ReleaseService } from './services/release-service.js'
+
+// Errors
+export { InvalidReleaseTokenError, ChangesetNotInitializedError } from './errors/release-errors.js'
+
+// Commands
+export { releaseInitCommand } from './commands/release-init.js'

package/src/modules/release/services/release-service.ts

@@ -0,0 +1,170 @@
+import chalk from 'chalk'
+import { password, confirm } from '@inquirer/prompts'
+import ora from 'ora'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { GitHubService } from '../../git/index.js'
+import { InvalidReleaseTokenError, ChangesetNotInitializedError } from '../errors/release-errors.js'
+
+export class ReleaseService {
+  constructor(private githubService: GitHubService = new GitHubService()) {}
+
+  /**
+   * Validate GitHub Personal Access Token format
+   */
+  validateReleaseToken(token: string): void {
+    if (!token || token.trim().length === 0) {
+      throw new InvalidReleaseTokenError('Token cannot be empty')
+    }
+
+    // GitHub PATs start with specific prefixes
+    if (!token.startsWith('ghp_') && !token.startsWith('github_pat_')) {
+      throw new InvalidReleaseTokenError('Invalid token format. GitHub PATs should start with "ghp_" or "github_pat_"')
+    }
+  }
+
+  /**
+   * Explain what RELEASE_TOKEN is and why it's needed
+   */
+  explainReleaseToken(): void {
+    console.log(chalk.cyan('\n📋 About RELEASE_TOKEN:\n'))
+    console.log(chalk.white('The RELEASE_TOKEN is a GitHub Personal Access Token (PAT) that allows'))
+    console.log(chalk.white('the Changesets action to create Pull Requests for version updates.\n'))
+    console.log(chalk.white('Why is this needed?'))
+    console.log(chalk.gray('  • The default GITHUB_TOKEN has limited permissions'))
+    console.log(chalk.gray('  • Creating PRs that trigger CI requires a PAT'))
+    console.log(chalk.gray('  • This enables automated release workflows\n'))
+    console.log(chalk.white('Required permissions:'))
+    console.log(chalk.gray('  • Contents: Read and write'))
+    console.log(chalk.gray('  • Pull requests: Read and write\n'))
+
+    // Provide link to create PAT
+    const tokenUrl = 'https://github.com/settings/personal-access-tokens/new'
+    console.log(chalk.cyan('🔗 Create your token:'))
+    console.log(chalk.gray(`   ${chalk.cyan(tokenUrl)}`))
+    console.log(chalk.gray(`   Name: Launch77 Release Token`))
+    console.log(chalk.gray(`   Permissions: Contents (Read and write), Pull requests (Read and write)\n`))
+  }
+
+  /**
+   * Prompt user for RELEASE_TOKEN
+   */
+  async promptForReleaseToken(): Promise<string> {
+    return password({
+      message: 'Paste your Personal Access Token (PAT):',
+      mask: '*',
+      validate: (value) => {
+        try {
+          this.validateReleaseToken(value)
+          return true
+        } catch (error) {
+          if (error instanceof InvalidReleaseTokenError) {
+            return error.message
+          }
+          return 'Invalid token'
+        }
+      },
+    })
+  }
+
+  /**
+   * Setup RELEASE_TOKEN secret in GitHub repository
+   */
+  async setupReleaseToken(owner: string, repo: string, token: string): Promise<void> {
+    this.validateReleaseToken(token)
+
+    // Confirm before setting
+    console.log(chalk.yellow('\n⚠ Note: This will overwrite any existing RELEASE_TOKEN secret\n'))
+    const shouldContinue = await confirm({
+      message: 'Continue and set RELEASE_TOKEN?',
+      default: true,
+    })
+
+    if (!shouldContinue) {
+      console.log(chalk.green('\n✅ No changes made.\n'))
+      process.exit(0)
+    }
+
+    // Set the secret
+    const setSpinner = ora('Setting RELEASE_TOKEN secret...').start()
+    try {
+      await this.githubService.setRepositorySecret(owner, repo, 'RELEASE_TOKEN', token)
+      setSpinner.succeed('RELEASE_TOKEN configured successfully!')
+    } catch (error) {
+      setSpinner.fail('Failed to set RELEASE_TOKEN')
+      throw error
+    }
+  }
+
+  /**
+   * Fix changeset config to set access to "public"
+   */
+  async fixChangesetAccess(workspaceRoot: string): Promise<boolean> {
+    const configPath = path.join(workspaceRoot, '.changeset', 'config.json')
+
+    try {
+      // Check if config exists
+      const configContent = await fs.readFile(configPath, 'utf-8')
+      const config = JSON.parse(configContent)
+
+      // Check if already public
+      if (config.access === 'public') {
+        return false // No change needed
+      }
+
+      // Update to public
+      config.access = 'public'
+
+      // Write back
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8')
+
+      return true // Changed
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        throw new ChangesetNotInitializedError()
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Explain npm Trusted Publishing (OIDC)
+   */
+  explainNpmTrustedPublishing(): void {
+    console.log(chalk.cyan('\n📦 Setting up npm publishing with Trusted Publishers (OIDC):\n'))
+    console.log(chalk.white('Trusted Publishing uses OpenID Connect (OIDC) for secure, token-free publishing.'))
+    console.log(chalk.white('This is the recommended approach (no tokens to manage or expire).\n'))
+
+    console.log(chalk.white('Steps to configure:'))
+    console.log(chalk.gray('  1. Visit: https://www.npmjs.com/settings/~/publishers'))
+    console.log(chalk.gray('  2. Click "Add a trusted publisher"'))
+    console.log(chalk.gray('  3. Select "GitHub Actions"'))
+    console.log(chalk.gray('  4. Enter your repository information:'))
+    console.log(chalk.gray('     - Repository owner (your GitHub username or org)'))
+    console.log(chalk.gray('     - Repository name'))
+    console.log(chalk.gray('     - Workflow file: .github/workflows/ci.yml'))
+    console.log(chalk.gray('  5. Save the configuration\n'))
+
+    console.log(chalk.white('Your GitHub workflow already has the required permission:'))
+    console.log(chalk.gray('  ✓ id-token: write\n'))
+
+    console.log(chalk.cyan('📚 Learn more:'))
+    console.log(chalk.gray('   https://docs.npmjs.com/trusted-publishers/\n'))
+  }
+
+  /**
+   * Show success summary for release setup
+   */
+  showSuccessSummary(): void {
+    console.log(chalk.green('\n✅ Release automation is ready!\n'))
+    console.log(chalk.white('What happens now:'))
+    console.log(chalk.gray('  • When you push to main, CI runs as usual'))
+    console.log(chalk.gray('  • Changesets detects version changes'))
+    console.log(chalk.gray('  • A "Version Packages" PR is created automatically'))
+    console.log(chalk.gray('  • Merge the PR to publish your packages\n'))
+
+    console.log(chalk.cyan('📚 Learn more:'))
+    console.log(chalk.gray(`   ${chalk.cyan('https://github.com/changesets/changesets')}\n`))
+  }
+}

package/src/utils/launch77-context.ts

@@ -2,7 +2,7 @@ import * as path from 'path'
 
 import fs from 'fs-extra'
 
-export type Launch77LocationType = 'workspace-root' | 'workspace-app' | 'unknown'
+export type Launch77LocationType = 'workspace-root' | 'workspace-app' | 'workspace-library' | 'workspace-plugin' | 'workspace-app-template' | 'unknown'
 
 export interface Launch77Context {
   isValid: boolean
@@ -64,6 +64,9 @@ interface ParsedLocation {
  * Parse the directory structure to determine location context
  * Based on patterns:
  * - apps/[name] → workspace-app
+ * - libraries/[name] → workspace-library
+ * - plugins/[name] → workspace-plugin
+ * - app-templates/[name] → workspace-app-template
  * - (empty or root) → workspace-root
  */
 function parseLocationFromPath(cwdPath: string, workspaceRoot: string): ParsedLocation {
@@ -84,8 +87,31 @@ function parseLocationFromPath(cwdPath: string, workspaceRoot: string): ParsedLo
     }
   }
 
-  // Somewhere else in workspace (libraries, plugins, etc.)
-  // Still considered workspace-root for now
+  // libraries/[lib-name]/...
+  if (parts[0] === 'libraries' && parts.length >= 2) {
+    return {
+      locationType: 'workspace-library',
+      appName: parts[1],
+    }
+  }
+
+  // plugins/[plugin-name]/...
+  if (parts[0] === 'plugins' && parts.length >= 2) {
+    return {
+      locationType: 'workspace-plugin',
+      appName: parts[1],
+    }
+  }
+
+  // app-templates/[template-name]/...
+  if (parts[0] === 'app-templates' && parts.length >= 2) {
+    return {
+      locationType: 'workspace-app-template',
+      appName: parts[1],
+    }
+  }
+
+  // Somewhere else in workspace
   return { locationType: 'workspace-root' }
 }
 

package/src/utils/launch77-validation.ts

@@ -1,4 +1,4 @@
-import type { Launch77Context } from './launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 
 /**
  * Validation result with helpful error messages

package/src/utils/string.ts

@@ -0,0 +1,17 @@
+/**
+ * Convert a kebab-case or snake_case string to PascalCase
+ *
+ * @param str - The string to convert (e.g., "my-plugin" or "my_plugin")
+ * @returns PascalCase string (e.g., "MyPlugin")
+ *
+ * @example
+ * toPascalCase('my-plugin') // 'MyPlugin'
+ * toPascalCase('release') // 'Release'
+ * toPascalCase('my-awesome-plugin') // 'MyAwesomePlugin'
+ */
+export function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}

package/templates/plugin/README.md.hbs

@@ -0,0 +1,39 @@
+# {{pluginNamePascal}} Plugin
+
+{{description}}
+
+## Installation
+
+```bash
+launch77 plugin:install {{pluginName}}
+```
+
+## Usage
+
+After installation, the plugin will:
+
+- TODO: Describe what the plugin does
+- TODO: List any files created or modified
+- TODO: Explain configuration options
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+npm run typecheck
+```
+
+## Template Files
+
+The `templates/` directory contains files that will be copied to the target application when this plugin is installed. Add any template files your plugin needs here.
+
+## License
+
+UNLICENSED