@launch77/cli 1.3.0 → 1.4.0

package/src/infrastructure/template.ts

@@ -57,6 +57,20 @@ export function getTemplatePath(templateName: string): string {
   return path.join(baseDir, templateName)
 }
 
+/**
+ * Get the path to a plugin template directory
+ * Plugin templates are in dist/templates/ (copied during build)
+ */
+export function getPluginTemplatePath(templateName: string): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+
+  // From dist/infrastructure/ to dist/templates/
+  const baseDir = path.join(__dirname, '../templates')
+
+  return path.join(baseDir, templateName)
+}
+
 /**
  * Check if a template exists
  */

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

@@ -5,7 +5,7 @@ import chalk from 'chalk'
 import { Command } from 'commander'
 import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
 import { APP_TYPES, APP_TYPES_LIST } from '../types/app-types.js'
 

package/src/modules/app/commands/delete-app.ts

@@ -6,7 +6,7 @@ import { Command } from 'commander'
 import inquirer from 'inquirer'
 import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
 
 export function deleteAppCommand(): Command {

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

@@ -10,7 +10,7 @@ import { templateExists } from '../../../infrastructure/template.js'
 import { validateWorkspaceContext } from '../../../utils/launch77-validation.js'
 import { validateAppName } from '../../../utils/validation.js'
 
-import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from '../types/app-types.js'
 
 export class AppService {

package/src/modules/app/services/manifest-svc.ts

@@ -3,7 +3,7 @@ import * as path from 'path'
 
 import { parseManifest } from '../lib/manifest-schema.js'
 
-import type { Launch77Context } from '../../../utils/launch77-context.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { AppManifest } from '../lib/manifest-schema.js'
 
 /**

package/src/modules/catalog/config/catalog-config.test.ts

@@ -159,7 +159,7 @@ describe('validateConfig', () => {
         type: 'server-functions',
         packageName: '@launch77/ui',
       }
-      expect(() => validateConfig(config)).toThrow('Type must be "ui-components"')
+      expect(() => validateConfig(config)).toThrow(/expected "ui-components"/)
     })
 
     test('type is number', () => {

package/src/modules/git/commands/git-connect.ts

@@ -3,7 +3,7 @@ import { Command } from 'commander'
 import { select, input, confirm } from '@inquirer/prompts'
 import ora from 'ora'
 
-import { detectLaunch77Context } from '../../../utils/launch77-context.js'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError, GitNotInstalledError } from '../errors/git-errors.js'
 import { GitHubService } from '../services/github-service.js'
 import { GitService } from '../services/git-service.js'
@@ -139,7 +139,7 @@ export function gitConnectCommand(): Command {
           // Success message
           console.log(chalk.green(`\n✅ Workspace connected to GitHub!\n`))
           console.log(chalk.white(`   Repository: ${chalk.cyan(repoUrl)}\n`))
-          console.log(chalk.gray(`Next steps:\n` + `  - Your code has been pushed to GitHub\n` + `  - GitHub Actions will run automatically\n` + `  - View your repository: ${chalk.cyan('gh repo view --web')}\n` + `\n` + `  ${chalk.yellow('📦 Enable automatic releases (recommended):')}\n` + `  - Run: ${chalk.cyan('launch77 git:setup-releases')}\n` + `  - This sets up the RELEASE_TOKEN for creating release PRs\n`))
+          console.log(chalk.gray(`Next steps:\n` + `  - Your code has been pushed to GitHub\n` + `  - GitHub Actions will run automatically\n` + `  - View your repository: ${chalk.cyan('gh repo view --web')}\n` + `\n` + `  ${chalk.yellow('📦 Enable automatic releases (recommended):')}\n` + `  - Run: ${chalk.cyan('launch77 release:init')}\n` + `  - This sets up complete release workflow (GitHub tokens, changesets, npm)\n`))
         } catch (error) {
           createSpinner.fail('Failed to create repository')
 

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

@@ -35,3 +35,10 @@ export class RepositoryAlreadyExistsError extends Error {
     this.name = 'RepositoryAlreadyExistsError'
   }
 }
+
+export class GitHubNotConnectedError extends Error {
+  constructor() {
+    super('This workspace is not connected to a GitHub repository')
+    this.name = 'GitHubNotConnectedError'
+  }
+}

package/src/modules/git/index.ts

@@ -1,2 +1,9 @@
+// Services (for other modules to use)
+export { GitService } from './services/git-service.js'
+export { GitHubService } from './services/github-service.js'
+
+// Errors (for proper error handling)
+export { GitHubCLINotInstalledError, GitHubNotAuthenticatedError, NotInWorkspaceError, GitNotInstalledError, RepositoryAlreadyExistsError, GitHubNotConnectedError } from './errors/git-errors.js'
+
+// Commands
 export { gitConnectCommand } from './commands/git-connect.js'
-export { gitSetupReleasesCommand } from './commands/git-setup-releases.js'

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

@@ -1,5 +1,5 @@
 import * as git from '../../../infrastructure/git.js'
-import { GitNotInstalledError } from '../errors/git-errors.js'
+import { GitNotInstalledError, GitHubNotConnectedError } from '../errors/git-errors.js'
 
 export class GitService {
   /**
@@ -49,4 +49,15 @@ export class GitService {
   async getRemoteUrl(cwd: string, remoteName: string = 'origin'): Promise<string> {
     return git.getRemoteUrl(cwd, remoteName)
   }
+
+  /**
+   * Ensure repository is connected to GitHub (has a remote)
+   * Throws GitHubNotConnectedError if not connected
+   */
+  async ensureConnectedToGitHub(cwd: string, remoteName: string = 'origin'): Promise<void> {
+    const hasOrigin = await this.hasRemote(cwd, remoteName)
+    if (!hasOrigin) {
+      throw new GitHubNotConnectedError()
+    }
+  }
 }

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

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

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

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

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

@@ -16,20 +16,71 @@ export class InvalidPluginContextError extends Error {
 
 /**
  * Factory function to create standardized InvalidPluginContextError
- * for when plugin:install is run outside of an app directory
+ * for when plugin:install is run outside of a package directory
  */
 export function createInvalidContextError(currentLocation: string): InvalidPluginContextError {
   return new InvalidPluginContextError(
-    `plugin:install must be run from within an app directory.
+    `plugin:install must be run from within a package directory.
 
 Current location: ${currentLocation}
-Expected: apps/<app-name>/
+Expected: apps/<name>/, libraries/<name>/, plugins/<name>/, or app-templates/<name>/
 
-Navigate to an app directory:
+Navigate to a package directory:
   cd apps/<app-name>/
+  cd libraries/<lib-name>/
+  cd plugins/<plugin-name>/
+  cd app-templates/<template-name>/`
+  )
+}
+
+/**
+ * Error when plugin.json is missing the required 'targets' field
+ */
+export class MissingPluginTargetsError extends Error {
+  constructor(pluginName: string) {
+    super(`Plugin '${pluginName}' is missing the required 'targets' field in plugin.json.
+
+The plugin.json file must include a 'targets' array specifying which package types
+the plugin can be installed into.
+
+Example plugin.json:
+{
+  "name": "${pluginName}",
+  "version": "1.0.0",
+  "targets": ["app", "library", "plugin", "app-template"],
+  "pluginDependencies": {},
+  "libraryDependencies": {}
+}`)
+    this.name = 'MissingPluginTargetsError'
+  }
+}
+
+/**
+ * Factory function to create error when plugin targets don't match current location
+ */
+export function createInvalidTargetError(pluginName: string, currentTarget: string, allowedTargets: string[]): InvalidPluginContextError {
+  const targetLocations = allowedTargets.map((target) => {
+    switch (target) {
+      case 'app':
+        return 'apps/<name>/'
+      case 'library':
+        return 'libraries/<name>/'
+      case 'plugin':
+        return 'plugins/<name>/'
+      case 'app-template':
+        return 'app-templates/<name>/'
+      default:
+        return target
+    }
+  })
+
+  return new InvalidPluginContextError(
+    `Plugin '${pluginName}' cannot be installed in a '${currentTarget}' package.
+
+This plugin can only be installed in: ${allowedTargets.join(', ')}
 
-Or create an app first:
-  launch77 app:create api <app-name>`
+Allowed locations:
+${targetLocations.map((loc) => `  ${loc}`).join('\n')}`
   )
 }
 
@@ -42,3 +93,33 @@ export class PluginInstallationError extends Error {
     this.name = 'PluginInstallationError'
   }
 }
+
+/**
+ * Error when plugin resolution fails
+ */
+export class PluginResolutionError extends Error {
+  constructor(pluginName: string, reason: string) {
+    super(`Failed to resolve plugin '${pluginName}': ${reason}`)
+    this.name = 'PluginResolutionError'
+  }
+}
+
+/**
+ * Error when npm package installation fails
+ */
+export class NpmInstallationError extends Error {
+  constructor(
+    packageName: string,
+    public readonly cause?: Error
+  ) {
+    super(`Failed to install npm package '${packageName}'.
+
+Please check:
+- Your internet connection
+- npm registry access (https://registry.npmjs.org)
+- Package exists: https://www.npmjs.com/package/${packageName}
+
+${cause ? `\nOriginal error: ${cause.message}` : ''}`)
+    this.name = 'NpmInstallationError'
+  }
+}

package/src/modules/plugin/index.ts

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

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

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