@launch77/cli 1.3.0 → 1.4.0

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

package/templates/plugin/package.json.hbs

@@ -0,0 +1,34 @@
+{
+  "name": "@{{workspaceName}}/plugin-{{pluginName}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "license": "UNLICENSED",
+  "private": true,
+  "type": "module",
+  "main": "dist/generator.js",
+  "bin": {
+    "generate": "./dist/generator.js"
+  },
+  "files": [
+    "dist/",
+    "templates/",
+    "plugin.json"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@launch77/plugin-runtime": "^0.1.0",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/templates/plugin/plugin.json.hbs

@@ -0,0 +1,7 @@
+{
+  "name": "{{pluginName}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "pluginDependencies": {},
+  "libraryDependencies": {}
+}

package/templates/plugin/src/generator.ts.hbs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk'
+import { StandardGenerator } from '@launch77/plugin-runtime'
+import type { GeneratorContext } from '@launch77/plugin-runtime'
+
+export class {{pluginNamePascal}}Generator extends StandardGenerator {
+  constructor(context: GeneratorContext) {
+    super(context)
+  }
+
+  protected async injectCode(): Promise<void> {
+    console.log(chalk.cyan('🔧 Setting up {{pluginName}} plugin...\n'))
+
+    // TODO: Add your plugin's code injection logic here
+    // Examples:
+    // - Copy template files to the app
+    // - Modify package.json
+    // - Update configuration files
+
+    console.log(chalk.green('   ✓ Plugin setup complete\n'))
+  }
+
+  protected showNextSteps(): void {
+    console.log(chalk.white('\n' + '─'.repeat(60) + '\n'))
+    console.log(chalk.cyan('📋 {{pluginNamePascal}} Plugin Installed!\n'))
+    console.log(chalk.white('Next Steps:\n'))
+
+    console.log(chalk.gray('1. TODO: Add your first step'))
+    console.log(chalk.cyan('   npm run <command>\n'))
+
+    console.log(chalk.gray('2. TODO: Add your second step'))
+    console.log(chalk.cyan('   npm run <command>\n'))
+
+    console.log(chalk.white('Documentation:\n'))
+    console.log(chalk.gray('See README.md for detailed instructions.\n'))
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2)
+  const appPath = args.find((arg) => arg.startsWith('--appPath='))?.split('=')[1]
+  const appName = args.find((arg) => arg.startsWith('--appName='))?.split('=')[1]
+  const workspaceName = args.find((arg) => arg.startsWith('--workspaceName='))?.split('=')[1]
+  const pluginPath = args.find((arg) => arg.startsWith('--pluginPath='))?.split('=')[1]
+
+  if (!appPath || !appName || !workspaceName || !pluginPath) {
+    console.error(chalk.red('Error: Missing required arguments'))
+    console.error(chalk.gray('Usage: --appPath=<path> --appName=<name> --workspaceName=<name> --pluginPath=<path>'))
+    process.exit(1)
+  }
+
+  const generator = new {{pluginNamePascal}}Generator({ appPath, appName, workspaceName, pluginPath })
+  await generator.run()
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error(chalk.red('\n❌ Error during plugin setup:'))
+    console.error(error)
+    process.exit(1)
+  })
+}

package/templates/plugin/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "ESNext",
+    "target": "ES2022"
+  },
+  "include": ["src/**/*"]
+}

package/templates/plugin/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/generator.ts'],
+  format: ['esm'],
+  dts: false,
+  clean: true,
+  shims: true,
+})

package/templates/workspace/.github/workflows/ci.yml

@@ -31,20 +31,23 @@ jobs:
           cache: 'npm'
 
       - name: Install dependencies
-        run: npm ci
+        run: npm install
 
       - name: Run linting
         run: npm run lint
 
-      - name: Run type checking
-        run: npm run typecheck
-
       - name: Build packages
         run: npm run build
 
+      - name: Run type checking
+        run: npm run typecheck
+
       - name: Run tests
         run: npm run test
 
+      - name: Run integration tests
+        run: npm run test:integration
+
   quality-checks:
     runs-on: ubuntu-latest
 
@@ -58,7 +61,7 @@ jobs:
           cache: 'npm'
 
       - name: Install dependencies
-        run: npm ci
+        run: npm install
 
       - name: Check for dependency vulnerabilities
         run: npm audit --audit-level=high

package/templates/workspace/package.json

@@ -13,6 +13,7 @@
     "dev": "turbo run dev",
     "build": "turbo run build",
     "test": "turbo run test",
+    "test:integration": "turbo run test:integration",
     "lint": "turbo run lint",
     "typecheck": "turbo run typecheck",
     "changeset": "changeset",

package/templates/workspace/turbo.json

@@ -20,6 +20,11 @@
     "test": {
       "outputs": [],
       "dependsOn": ["build"]
+    },
+    "test:integration": {
+      "outputs": [],
+      "dependsOn": ["build"],
+      "cache": false
     }
   }
 }

package/tests/integration/cli.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { existsSync } from 'fs'
+import { runCli } from './setup.js'
+
+describe('CLI Integration Tests', () => {
+  beforeAll(() => {
+    if (!existsSync('./dist/cli.js')) {
+      throw new Error('CLI not built. Run `npm run build` first.')
+    }
+  })
+
+  it('should display version', async () => {
+    const { stdout, exitCode } = await runCli(['--version'])
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toMatch(/\d+\.\d+\.\d+/)
+  })
+
+  it('should display help', async () => {
+    const { stdout, exitCode } = await runCli(['--help'])
+
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain('launch77')
+  })
+})

package/tests/integration/setup.ts

@@ -0,0 +1,20 @@
+import { execa } from 'execa'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_PATH = join(__dirname, '../../dist/cli.js')
+
+export async function runCli(args: string[], options?: { cwd?: string }) {
+  const result = await execa('node', [CLI_PATH, ...args], {
+    reject: false,
+    cwd: options?.cwd,
+    env: { ...process.env, CI: 'true' },
+  })
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 0,
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    testTimeout: 10000,
+    hookTimeout: 10000,
+  },
+})

package/vitest.integration.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    include: ['tests/integration/**/*.test.ts'],
+    testTimeout: 30000,
+    hookTimeout: 60000,
+  },
+})