@launch77/cli 1.4.4 → 1.6.0

package/src/cli.ts

@@ -2,15 +2,15 @@
 
 import { Command } from 'commander'
 
-import { createAppCommand, deleteAppCommand, generateManifestCommand, validateManifestCommand } from './modules/app/index.js'
-import { scanCommand, createGenerateCommand } from './modules/catalog/index.js'
-import { deployInitCommand, deployLogsCommand, deployStatusCommand } from './modules/deploy/index.js'
+import { appCreateCommand, appDeleteCommand } from './modules/app/index.js'
+// import { catalogScanCommand, catalogGenerateCommand } from './modules/catalog/index.js'
+// import { deployInitCommand, deployLogsCommand, deployStatusCommand } from './modules/deploy/index.js'
 import { gitConnectCommand } from './modules/git/index.js'
-import { pluginInstallCommand, pluginCreateCommand } from './modules/plugin/index.js'
+import { libraryDeleteCommand } from './modules/library/index.js'
+import { pluginInstallCommand, pluginCreateCommand, pluginDeleteCommand } from './modules/plugin/index.js'
 import { releaseInitCommand } from './modules/release/index.js'
-import { createStartupCommand } from './modules/startup/index.js'
-import { getPackageVersion } from './utils/version.js'
 import { initWorkspaceCommand } from './modules/workspace/index.js'
+import { getPackageVersion } from './utils/version.js'
 
 const program = new Command()
   .name('launch77')
@@ -19,15 +19,14 @@ const program = new Command()
 
 // Register module commands
 program.addCommand(initWorkspaceCommand())
-program.addCommand(createStartupCommand())
-program.addCommand(createAppCommand())
-program.addCommand(deleteAppCommand())
-program.addCommand(generateManifestCommand())
-program.addCommand(validateManifestCommand())
-program.addCommand(pluginInstallCommand())
+program.addCommand(appCreateCommand())
+program.addCommand(appDeleteCommand())
+program.addCommand(libraryDeleteCommand())
 program.addCommand(pluginCreateCommand())
-program.addCommand(scanCommand())
-program.addCommand(createGenerateCommand())
+program.addCommand(pluginDeleteCommand())
+program.addCommand(pluginInstallCommand())
+// program.addCommand(catalogGenerateCommand())
+// program.addCommand(catalogScanCommand())
 
 // Git commands
 program.addCommand(gitConnectCommand())
@@ -36,8 +35,8 @@ program.addCommand(gitConnectCommand())
 program.addCommand(releaseInitCommand())
 
 // Deploy commands
-program.addCommand(deployInitCommand())
-program.addCommand(deployStatusCommand())
-program.addCommand(deployLogsCommand())
+// program.addCommand(deployInitCommand())
+// program.addCommand(deployStatusCommand())
+// program.addCommand(deployLogsCommand())
 
 program.parse()

package/src/infrastructure/package-resolver.test.ts

@@ -177,7 +177,7 @@ describe('PackageResolver', () => {
         const packageName = 'my-local-package'
         const localPath = path.join(tempDir, 'test-packages', packageName)
         await fs.ensureDir(localPath)
-        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName, version: '0.0.1' })
 
         const result = await resolver.resolveLocation(packageName, tempDir)
 
@@ -216,7 +216,7 @@ describe('PackageResolver', () => {
         const packageName = 'my-package'
         const localPath = path.join(tempDir, 'test-packages', packageName)
         await fs.ensureDir(localPath)
-        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName, version: '0.0.1' })
 
         const result = await resolver.resolveLocation('  my-package  ', tempDir)
 
@@ -301,7 +301,7 @@ describe('PackageResolver', () => {
         const packageName = 'my-package'
         const localPath = path.join(customRoot, 'test-packages', packageName)
         await fs.ensureDir(localPath)
-        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName })
+        await fs.writeJSON(path.join(localPath, 'package.json'), { name: packageName, version: '0.0.1' })
 
         const result = await resolver.resolveLocation(packageName, customRoot)
 

package/src/infrastructure/package-resolver.ts

@@ -17,6 +17,8 @@ export interface PackageResolution {
   localPath?: string
   /** The npm package name if source is 'npm' */
   npmPackage?: string
+  /** The version from package.json (required for local packages, undefined for npm until installed) */
+  version?: string
 }
 
 /**
@@ -127,6 +129,30 @@ export abstract class PackageResolver {
     return `${this.getPackagePrefix()}${trimmedName}`
   }
 
+  /**
+   * Read version from package.json
+   * @param packagePath - The path to the package directory
+   * @returns The version string from package.json
+   * @throws If package.json doesn't exist, can't be read, or is missing the version field
+   */
+  private async readVersion(packagePath: string): Promise<string> {
+    const packageJsonPath = path.join(packagePath, 'package.json')
+    try {
+      const packageJson = await fs.readJson(packageJsonPath)
+      if (!packageJson.version) {
+        throw new Error(`Invalid package structure: package.json at ${packagePath} is missing required version field. ` + `All Launch77 packages must include a valid package.json with a version field.`)
+      }
+      return packageJson.version
+    } catch (error) {
+      // Re-throw our own error messages
+      if (error instanceof Error && error.message.includes('Invalid package structure')) {
+        throw error
+      }
+      // File not found or invalid JSON
+      throw new Error(`Invalid package structure: package.json not found or invalid at ${packagePath}. ` + `All Launch77 packages must include a valid package.json with a version field.`)
+    }
+  }
+
   /**
    * Resolve package location from name
    *
@@ -134,15 +160,16 @@ export abstract class PackageResolver {
    * 1. Check local workspace directory (configured by getFolderName())
    * 2. Verify local package is valid (using verify())
    * 3. Fall back to npm package name (with configured prefix)
+   * 4. Read version from package.json (if available)
    *
    * @param name - The package name to resolve
    * @param workspaceRoot - The workspace root directory
-   * @returns PackageResolution with source and resolved location
+   * @returns PackageResolution with source, resolved location, and version
    *
    * @example
    * // Local package found
    * await resolveLocation('my-package', '/workspace')
-   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package' }
+   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package', version: '1.0.0' }
    *
    * // Not found locally, resolve to npm
    * await resolveLocation('release', '/workspace')
@@ -174,10 +201,12 @@ export abstract class PackageResolver {
       const isValid = await this.verify(localPath)
 
       if (isValid) {
+        const version = await this.readVersion(localPath)
         return {
           source: 'local',
           resolvedName: trimmedName,
           localPath,
+          version,
         }
       }
     }

package/src/infrastructure/template.ts

@@ -6,7 +6,6 @@ import Handlebars from 'handlebars'
 
 export interface TemplateContext {
   appName: string
-  startupName?: string
   port?: string
   [key: string]: string | number | boolean | undefined
 }

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

@@ -7,27 +7,19 @@ import ora from 'ora'
 
 import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
-import { APP_TYPES, APP_TYPES_LIST } from '../types/app-types.js'
 
-import type { AppType } from '../types/app-types.js'
-
-export function createAppCommand(): Command {
+export function appCreateCommand(): Command {
   const command = new Command('app:create')
-    .argument('<type>', 'App type (api, webapp, marketing-site)')
+    .argument('<template>', 'App template name (e.g., webapp, api, marketing-site)')
     .argument('<app-name>', 'Name of the application')
-    .description('Create a new application')
-    .option('-p, --port <port>', 'Default port for the app')
-    .action(async (type: string, appName: string, options) => {
+    .description('Create a new application from a template')
+    .option('-p, --port <port>', 'Default port for the app (default: 3000)')
+    .action(async (template: string, appName: string, options) => {
       try {
-        // Validate app type
-        if (!APP_TYPES.includes(type as AppType)) {
-          throw new Error(`Invalid app type: ${type}\n\nSupported types: ${APP_TYPES_LIST}`)
-        }
-
-        console.log(chalk.blue(`\n🚀 Creating ${type} app: ${appName}\n`))
+        console.log(chalk.blue(`\n🚀 Creating app: ${appName} from template: ${template}\n`))
 
-        // Set default port based on app type
-        const port = options.port || (type === 'marketing-site' || type === 'webapp' ? '3000' : '4000')
+        // Set default port
+        const port = options.port || '3000'
 
         // Detect context
         const context = await detectLaunch77Context(process.cwd())
@@ -39,7 +31,7 @@ export function createAppCommand(): Command {
         const templateSpinner = ora('Generating app structure...').start()
         let result
         try {
-          result = await appService.createApp({ type: type as AppType, appName, port }, context)
+          result = await appService.createApp({ type: template, appName, port }, context)
           templateSpinner.succeed('App structure generated')
         } catch (error) {
           templateSpinner.fail('Failed to generate app structure')

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

@@ -9,10 +9,10 @@ import ora from 'ora'
 import { detectLaunch77Context } from '@launch77/plugin-runtime'
 import { AppService } from '../services/app-svc.js'
 
-export function deleteAppCommand(): Command {
+export function appDeleteCommand(): Command {
   const command = new Command('app:delete')
     .argument('<app-name>', 'Name of the app to delete')
-    .description('Delete an app from the startup (requires confirmation)')
+    .description('Delete an app from the workspace (requires confirmation)')
     .action(async (appName: string) => {
       try {
         console.log(chalk.yellow(`\n⚠️  WARNING: You are about to delete the app '${appName}'\n`))

package/src/modules/app/index.ts

@@ -3,14 +3,12 @@ export { AppService } from './services/app-svc.js'
 export { ManifestService } from './services/manifest-svc.js'
 
 // Types
-export type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult, AppType } from './types/app-types.js'
+export type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from './types/app-types.js'
 export type { AppManifest, DeploymentConfig } from './lib/manifest-schema.js'
 
 // Errors
 export { AppAlreadyExistsError, AppNotFoundError, InvalidAppNameError, TemplateNotFoundError, ManifestNotFoundError, InvalidManifestError } from './errors/app-errors.js'
 
 // Commands
-export { createAppCommand } from './commands/create-app.js'
-export { deleteAppCommand } from './commands/delete-app.js'
-export { generateManifestCommand } from './commands/generate-manifest.js'
-export { validateManifestCommand } from './commands/validate-manifest.js'
+export { appCreateCommand } from './commands/create-app.js'
+export { appDeleteCommand } from './commands/delete-app.js'

package/src/modules/app/lib/app-template-resolver.ts

@@ -21,6 +21,22 @@ export class AppTemplateResolver extends PackageResolver {
   }
 
   protected async verify(localPath: string): Promise<boolean> {
+    // All Launch77 packages must have package.json with version
+    const hasPackageJson = await fs.pathExists(path.join(localPath, 'package.json'))
+    if (!hasPackageJson) {
+      return false
+    }
+
+    // Verify package.json has a version field
+    try {
+      const packageJson = await fs.readJson(path.join(localPath, 'package.json'))
+      if (!packageJson.version) {
+        return false
+      }
+    } catch {
+      return false
+    }
+
     // Check for either:
     // 1. A 'template' subdirectory (preferred structure for npm packages)
     // 2. Any files at the root (simple local templates)

package/src/modules/app/lib/manifest-schema.ts

@@ -1,7 +1,5 @@
 import { z } from 'zod'
 
-import type { AppType } from '../types/app-types.js'
-
 // Deployment configuration
 export type DeploymentConfig = {
   platform: 'vercel'
@@ -14,7 +12,6 @@ export type DeploymentConfig = {
 export type AppManifest = {
   schemaVersion: 1
   name: string
-  type: AppType | 'marketing' // Support both 'marketing' and 'marketing-site'
   package: string
   deployment?: DeploymentConfig
 }
@@ -28,12 +25,10 @@ const deploymentConfigZ = z.object({
 })
 
 // Main manifest schema - strict mode to reject extra fields
-// Note: Manifests store 'marketing' but we accept 'marketing-site' in commands
 export const manifestZ = z
   .object({
     schemaVersion: z.literal(1),
     name: z.string().min(1),
-    type: z.enum(['marketing', 'webapp', 'api']),
     package: z.string().min(1),
     deployment: deploymentConfigZ.optional(),
   })

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

@@ -1,6 +1,7 @@
 import * as path from 'path'
 
 import fs from 'fs-extra'
+import { readTemplateMetadata } from '@launch77/plugin-runtime'
 
 import { ManifestService } from './manifest-svc.js'
 import * as filesystem from '../../../infrastructure/filesystem.js'
@@ -12,7 +13,7 @@ import { validateAppName } from '../../../utils/validation.js'
 import { AppTemplateResolver } from '../lib/app-template-resolver.js'
 
 import type { CreateAppRequest, CreateAppResult, DeleteAppRequest, DeleteAppResult } from '../types/app-types.js'
-import type { Launch77Context } from '@launch77/plugin-runtime'
+import type { Launch77Context, TemplateReference, Launch77PackageManifest } from '@launch77/plugin-runtime'
 
 export class AppService {
   private manifestService: ManifestService
@@ -51,9 +52,14 @@ export class AppService {
     const templateResolution = await this.appTemplateResolver.resolveLocation(type, context.workspaceRoot)
 
     let templatePath: string
+    let templateVersion: string
+    let packageRootPath: string
+
     if (templateResolution.source === 'local') {
       // Use local template
-      templatePath = templateResolution.localPath!
+      packageRootPath = templateResolution.localPath!
+      templatePath = packageRootPath
+      templateVersion = templateResolution.version! // Local templates always have version after verification
     } else {
       // Download npm template
       const downloadResult = await downloadNpmPackage({
@@ -61,13 +67,20 @@ export class AppService {
         workspaceRoot: context.workspaceRoot,
       })
 
+      packageRootPath = downloadResult.packagePath
+
       // Check if template has a 'template' subdirectory, otherwise use package root
-      const templateSubdir = path.join(downloadResult.packagePath, 'template')
+      const templateSubdir = path.join(packageRootPath, 'template')
       if (await fs.pathExists(templateSubdir)) {
         templatePath = templateSubdir
       } else {
-        templatePath = downloadResult.packagePath
+        templatePath = packageRootPath
       }
+
+      // Read version from downloaded package
+      const packageJsonPath = path.join(packageRootPath, 'package.json')
+      const packageJson = await fs.readJson(packageJsonPath)
+      templateVersion = packageJson.version
     }
 
     // 5. Determine app path
@@ -91,14 +104,40 @@ export class AppService {
       port,
     })
 
-    // 9. Generate and write app manifest
-    const manifest = this.manifestService.generateManifest(type, appName, context, { port })
+    // 9. Read template metadata (currently empty, placeholder for future config)
+    //const templateMetadata = await readTemplateMetadata(templatePath)
+
+    // 10. Write template reference to app's package.json
+    const appPackageJsonPath = path.join(appPath, 'package.json')
+    const appPackageJson = await fs.readJson(appPackageJsonPath)
+
+    // Build template reference - version read from package.json
+    const templatePackage = templateResolution.source === 'npm' ? templateResolution.npmPackage! : templateResolution.resolvedName
+    const templateRef: TemplateReference = {
+      package: templatePackage,
+      version: templateVersion,
+      source: templateResolution.source,
+      createdAt: new Date().toISOString(),
+    }
+
+    // Initialize launch77 manifest structure
+    if (!appPackageJson.launch77) {
+      appPackageJson.launch77 = {}
+    }
+    const launch77Manifest = appPackageJson.launch77 as Launch77PackageManifest
+    launch77Manifest.template = templateRef
+
+    // Write updated package.json
+    await fs.writeJson(appPackageJsonPath, appPackageJson, { spaces: 2 })
+
+    // 11. Generate and write app manifest
+    const manifest = this.manifestService.generateManifest(appName, context, { port })
     const launchDir = path.join(appPath, '.launch')
     await filesystem.ensureDir(launchDir)
     const manifestPath = path.join(launchDir, 'app.json')
     await filesystem.writeJSON(manifestPath, manifest)
 
-    // 10. Install dependencies
+    // 12. Install dependencies
     await npm.install(context.workspaceRoot)
 
     return {

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

@@ -8,7 +8,7 @@ import type { AppManifest } from '../lib/manifest-schema.js'
 
 /**
  * Convert kebab-case to Title Case
- * e.g., "my-startup-name" -> "My Startup Name"
+ * e.g., "my-workspace-name" -> "My Workspace Name"
  */
 function toTitleCase(str: string): string {
   return str
@@ -17,66 +17,17 @@ function toTitleCase(str: string): string {
     .join(' ')
 }
 
-/**
- * Generate a manifest for a marketing app
- */
-function generateMarketingManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} Marketing`,
-    type: 'marketing',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
-/**
- * Generate a manifest for a webapp
- */
-function generateWebappManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} Web`,
-    type: 'webapp',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
-/**
- * Generate a manifest for an API app
- */
-function generateApiManifest(appName: string, context: Launch77Context): AppManifest {
-  const workspaceName = context.workspaceName
-
-  return {
-    schemaVersion: 1,
-    name: `${toTitleCase(workspaceName)} API`,
-    type: 'api',
-    package: `@${workspaceName}/${appName}`,
-  }
-}
-
 export class ManifestService {
   /**
-   * Generate an app manifest based on app type
+   * Generate an app manifest
    */
-  generateManifest(type: string, appName: string, context: Launch77Context, _options: { port?: string }): AppManifest {
-    switch (type) {
-      case 'marketing-site':
-      case 'marketing':
-        return generateMarketingManifest(appName, context)
-
-      case 'webapp':
-        return generateWebappManifest(appName, context)
-
-      case 'api':
-        return generateApiManifest(appName, context)
+  generateManifest(appName: string, context: Launch77Context, _options: { port?: string }): AppManifest {
+    const workspaceName = context.workspaceName
 
-      default:
-        throw new Error(`Unsupported app type for manifest generation: ${type}. Supported types: api, webapp, marketing-site`)
+    return {
+      schemaVersion: 1,
+      name: toTitleCase(workspaceName),
+      package: `@${workspaceName}/${appName}`,
     }
   }
 

package/src/modules/app/types/app-types.ts

@@ -1,12 +1,5 @@
-// Supported app types
-export const APP_TYPES = ['api', 'webapp', 'marketing-site'] as const
-export type AppType = (typeof APP_TYPES)[number]
-
-// Display list for error messages
-export const APP_TYPES_LIST = APP_TYPES.join(', ')
-
 export interface CreateAppRequest {
-  type: AppType
+  type: string
   appName: string
   port: string
 }
@@ -14,7 +7,7 @@ export interface CreateAppRequest {
 export interface CreateAppResult {
   appPath: string
   appName: string
-  type: AppType
+  type: string
 }
 
 export interface DeleteAppRequest {

package/src/modules/catalog/commands/generate.ts

@@ -21,7 +21,7 @@ interface GenerateOptions {
 /**
  * Create the catalog:generate command
  */
-export function createGenerateCommand(): Command {
+export function catalogGenerateCommand(): Command {
   const command = new Command('catalog:generate')
     .description('Generate catalog metadata for a component library')
     .option('-l, --library <path>', 'Library directory path', process.cwd())

package/src/modules/catalog/commands/scan.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk'
 import { Command } from 'commander'
+import { detectLaunch77Context } from '@launch77/plugin-runtime'
 
-import { detectMonorepoContext } from '../../../utils/monorepo.js'
 import { CatalogService } from '../services/catalog-svc.js'
 
 /**
@@ -10,17 +10,17 @@ import { CatalogService } from '../services/catalog-svc.js'
  * Scans UI components, libraries, plugins, and utilities from the Launch77 monorepo
  * and generates a machine-readable catalog for AI discovery.
  */
-export function scanCommand(): Command {
+export function catalogScanCommand(): Command {
   const command = new Command('catalog:scan')
     .description('Scan Launch77 artifacts and generate catalog.json')
     .option('--no-strict', 'Skip validation errors and generate catalog anyway')
     .option('--quiet', 'Suppress quality report output')
     .action(async (options) => {
       try {
-        const context = await detectMonorepoContext(process.cwd())
+        const context = await detectLaunch77Context(process.cwd())
 
         if (!context.isValid) {
-          console.error(chalk.red('\n✖ Must be run from within a Launch77 monorepo\n'))
+          console.error(chalk.red('\n✖ Must be run from within a Launch77 workspace\n'))
           process.exit(1)
         }
 

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

@@ -9,7 +9,7 @@ import { scanUILibrary } from '../scanners/ui-component-scanner.js'
 import { generateExamplesFiles } from '../utils/examples-generator.js'
 import { generateQualityReport, printQualityReport } from '../utils/quality-reporter.js'
 
-import type { MonorepoContext } from '../../../utils/monorepo.js'
+import type { Launch77Context } from '@launch77/plugin-runtime'
 import type { ValidationResult, UiComponent } from '../types/catalog-types.js'
 
 export interface ScanCatalogOptions {
@@ -32,13 +32,13 @@ export class CatalogService {
   /**
    * Scan Launch77 codebase and generate catalog.json
    */
-  async scanCatalog(context: MonorepoContext, options: ScanCatalogOptions = {}): Promise<ScanCatalogResult> {
+  async scanCatalog(context: Launch77Context, options: ScanCatalogOptions = {}): Promise<ScanCatalogResult> {
     const strict = options.strict !== false // Default to true (strict mode)
     const quiet = options.quiet || false
 
     console.log(chalk.blue('\n🔍 Scanning Launch77 artifacts...\n'))
 
-    const launch77Root = path.join(context.monorepoRoot, 'launch77')
+    const launch77Root = path.join(context.workspaceRoot, 'launch77')
 
     const spinner = ora('Scanning codebase...').start()
 
@@ -109,7 +109,7 @@ export class CatalogService {
     console.log(chalk.green(`  ✓ Saved to ${path.relative(process.cwd(), catalogPath)}`))
 
     // Sync catalog to Launch77 marketing site
-    const marketingSiteCatalogPath = path.join(context.monorepoRoot, 'startups/launch77/apps/marketing/src/catalog.json')
+    const marketingSiteCatalogPath = path.join(context.workspaceRoot, 'apps/marketing/src/catalog.json')
 
     if (await fs.pathExists(path.dirname(marketingSiteCatalogPath))) {
       await fs.writeFile(marketingSiteCatalogPath, formatted)