@launch77/cli 1.2.0 → 1.4.0

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

@@ -0,0 +1,160 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+import { parsePluginName, isValidNpmPackageName } from '@launch77/plugin-runtime'
+
+import type { ValidationResult } from '@launch77/plugin-runtime'
+
+/**
+ * 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
+ *
+ * @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'
+ */
+export function toNpmPackageName(name: string): string {
+  const trimmedName = name.trim()
+
+  // If already scoped, use as-is
+  if (trimmedName.startsWith('@')) {
+    return trimmedName
+  }
+
+  // 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,
+    }
+  }
+
+  // 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)
+    const hasPluginJson = await fs.pathExists(path.join(localPath, 'plugin.json'))
+    const hasGenerator = await fs.pathExists(path.join(localPath, 'dist/generator.js'))
+
+    if (hasPluginJson && hasGenerator) {
+      return {
+        source: 'local',
+        resolvedName: trimmedName,
+        localPath,
+      }
+    }
+  }
+
+  // Not found locally, resolve to npm package
+  const npmPackage = toNpmPackageName(trimmedName)
+
+  return {
+    source: 'npm',
+    resolvedName: trimmedName,
+    npmPackage,
+  }
+}

package/src/modules/plugin/services/plugin-create-service.ts

@@ -0,0 +1,69 @@
+import * as path from 'path'
+
+import fs from 'fs-extra'
+
+import { validatePluginName } from '@launch77/plugin-runtime'
+import { processTemplate, getPluginTemplatePath } from '../../../infrastructure/template.js'
+import { toPascalCase } from '../../../utils/string.js'
+
+import type { Launch77Context } from '@launch77/plugin-runtime'
+
+export interface CreatePluginRequest {
+  pluginName: string
+  description?: string
+}
+
+export interface CreatePluginResult {
+  pluginName: string
+  pluginPath: string
+}
+
+export class PluginCreateService {
+  /**
+   * Create a new plugin from template
+   */
+  async createPlugin(request: CreatePluginRequest, context: Launch77Context): Promise<CreatePluginResult> {
+    const { pluginName, description } = request
+
+    // 1. Validate plugin name
+    const nameValidation = validatePluginName(pluginName)
+    if (!nameValidation.isValid) {
+      throw new Error(nameValidation.error || 'Invalid plugin name')
+    }
+
+    // 2. Validate workspace context
+    if (!context.isValid) {
+      throw new Error('Must be run from within a Launch77 workspace')
+    }
+
+    // 3. Determine plugin path
+    const pluginPath = path.join(context.workspaceRoot, 'plugins', pluginName)
+
+    // 4. Check if plugin already exists
+    if (await fs.pathExists(pluginPath)) {
+      throw new Error(`Plugin '${pluginName}' already exists at ${pluginPath}`)
+    }
+
+    // 5. Get plugin template path
+    const templatePath = getPluginTemplatePath('plugin')
+
+    // 6. Check if template exists
+    if (!(await fs.pathExists(templatePath))) {
+      throw new Error(`Plugin template not found at ${templatePath}`)
+    }
+
+    // 7. Process template with context
+    await processTemplate(templatePath, pluginPath, {
+      appName: pluginName, // Required by TemplateContext but not used for plugin templates
+      pluginName,
+      pluginNamePascal: toPascalCase(pluginName),
+      workspaceName: context.workspaceName,
+      description: description || `Launch77 plugin for ${pluginName}`,
+    })
+
+    return {
+      pluginName,
+      pluginPath,
+    }
+  }
+}

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

@@ -1,34 +1,90 @@
 import * as path from 'path'
 
+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 } 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
+   * Install a plugin to the current package
    */
-  async installPlugin(request: InstallPluginRequest, context: Launch77Context): Promise<InstallPluginResult> {
+  async installPlugin(request: InstallPluginRequest, context: Launch77Context, logger: (message: string) => void = console.log): Promise<InstallPluginResult> {
     const { pluginName } = request
 
-    // 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.')
+    // Must be in a package directory (app, library, plugin, or app-template)
+    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.')
+
+    // Step 1: Validate plugin input
+    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`)
+
+    // Step 2: Resolve plugin location
+    logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
+    const resolution = await resolvePluginLocation(pluginName, context.workspaceRoot)
 
-    // Get app directory path
-    const appPath = path.join(context.appsDir, context.appName)
+    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)}`)
+
+      // Download npm plugin
+      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, context.workspaceRoot, logger)
+    }
+
+    logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
+
+    // Step 3: Read plugin metadata and validate targets
+    const metadata = await readPluginMetadata(pluginPath)
+
+    if (!metadata.targets || metadata.targets.length === 0) {
+      throw new MissingPluginTargetsError(pluginName)
+    }
 
-    // Check if plugin exists
-    if (!(await pluginExists(pluginName))) throw new PluginNotFoundError(pluginName)
+    if (!metadata.targets.includes(currentTarget)) {
+      throw createInvalidTargetError(pluginName, currentTarget, metadata.targets)
+    }
 
-    const pluginPath = getPluginPath(pluginName)
+    // Step 4: Get package directory path
+    const packagePath = this.getPackagePath(context)
 
-    // Run generator
-    await this.runGenerator(pluginPath, appPath, context)
+    // Step 5: Run generator
+    await this.runGenerator(pluginPath, packagePath, context)
 
     return {
       pluginName,
@@ -38,6 +94,43 @@ 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')

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`))
+  }
+}