@launch77/cli 1.2.0

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

@@ -0,0 +1,233 @@
+import path from 'path'
+
+import fs from 'fs-extra'
+import { describe, test, expect, beforeEach, afterEach } from 'vitest'
+
+import { CatalogGeneratorService } from './catalog-generator-svc.js'
+
+import type { CatalogConfig } from '../types/catalog-types.js'
+
+describe('CatalogGeneratorService', () => {
+  const service = new CatalogGeneratorService()
+  const testDir = path.join(process.cwd(), '.test-temp', 'catalog-generator')
+
+  beforeEach(async () => {
+    // Create test directory
+    await fs.ensureDir(testDir)
+  })
+
+  afterEach(async () => {
+    // Clean up test directory
+    await fs.remove(testDir)
+  })
+
+  describe('generateForLibrary', () => {
+    test('throws error if package.json not found', async () => {
+      const emptyDir = path.join(testDir, 'empty-lib')
+      await fs.ensureDir(emptyDir)
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'catalog-ui-components.json',
+        catalogVersion: '0.1.0',
+        validation: {
+          strict: true,
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      await expect(service.generateForLibrary(emptyDir, config)).rejects.toThrow('package.json not found')
+    })
+
+    test('throws error if package.json has no version', async () => {
+      const libDir = path.join(testDir, 'no-version-lib')
+      await fs.ensureDir(libDir)
+      await fs.writeJson(path.join(libDir, 'package.json'), { name: '@test/lib' })
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'catalog-ui-components.json',
+        catalogVersion: '0.1.0',
+        validation: {
+          strict: true,
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      await expect(service.generateForLibrary(libDir, config)).rejects.toThrow('does not have a version field')
+    })
+
+    test('generates empty catalog for library with no components', async () => {
+      const libDir = path.join(testDir, 'empty-components-lib')
+      await fs.ensureDir(path.join(libDir, 'src'))
+      await fs.writeJson(path.join(libDir, 'package.json'), {
+        name: '@test/lib',
+        version: '1.0.0',
+      })
+      await fs.writeFile(path.join(libDir, 'src', 'index.ts'), '// No exports')
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'catalog-ui-components.json',
+        catalogVersion: '0.1.0',
+        validation: {
+          strict: false, // Non-strict to allow empty catalog
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      const result = await service.generateForLibrary(libDir, config)
+
+      expect(result.success).toBe(true)
+      expect(result.qualityReport.totalComponents).toBe(0)
+      expect(await fs.pathExists(path.join(libDir, 'catalog-ui-components.json'))).toBe(true)
+
+      const catalog = await fs.readJson(path.join(libDir, 'catalog-ui-components.json'))
+      expect(catalog.catalogType).toBe('ui-components')
+      expect(catalog.catalogVersion).toBe('0.1.0')
+      expect(catalog.packageName).toBe('@test/lib')
+      expect(catalog.packageVersion).toBe('1.0.0')
+      expect(catalog.components).toEqual([])
+      expect(catalog.generatedAt).toBeTruthy()
+    })
+
+    test('writes catalog to configured output file', async () => {
+      const libDir = path.join(testDir, 'custom-output-lib')
+      await fs.ensureDir(path.join(libDir, 'src'))
+      await fs.writeJson(path.join(libDir, 'package.json'), {
+        name: '@test/lib',
+        version: '2.0.0',
+      })
+      await fs.writeFile(path.join(libDir, 'src', 'index.ts'), '// No exports')
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'custom-catalog.json', // Custom output file
+        catalogVersion: '1.2.3',
+        validation: {
+          strict: false,
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      const result = await service.generateForLibrary(libDir, config)
+
+      expect(result.success).toBe(true)
+      expect(result.catalogFile).toBe(path.join(libDir, 'custom-catalog.json'))
+      expect(await fs.pathExists(path.join(libDir, 'custom-catalog.json'))).toBe(true)
+
+      const catalog = await fs.readJson(path.join(libDir, 'custom-catalog.json'))
+      expect(catalog.catalogVersion).toBe('1.2.3')
+      expect(catalog.packageVersion).toBe('2.0.0')
+    })
+
+    test('catalog includes correct metadata structure', async () => {
+      const libDir = path.join(testDir, 'metadata-lib')
+      await fs.ensureDir(path.join(libDir, 'src'))
+      await fs.writeJson(path.join(libDir, 'package.json'), {
+        name: '@test/meta-lib',
+        version: '3.1.4',
+      })
+      await fs.writeFile(path.join(libDir, 'src', 'index.ts'), '')
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/meta-lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'catalog-ui-components.json',
+        catalogVersion: '2.0.0',
+        validation: {
+          strict: false,
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      const result = await service.generateForLibrary(libDir, config)
+
+      expect(result.success).toBe(true)
+
+      const catalog = await fs.readJson(path.join(libDir, 'catalog-ui-components.json'))
+
+      // Verify required fields
+      expect(catalog).toHaveProperty('catalogType', 'ui-components')
+      expect(catalog).toHaveProperty('catalogVersion', '2.0.0')
+      expect(catalog).toHaveProperty('packageName', '@test/meta-lib')
+      expect(catalog).toHaveProperty('packageVersion', '3.1.4')
+      expect(catalog).toHaveProperty('generatedAt')
+      expect(catalog).toHaveProperty('components')
+
+      // Verify generatedAt is valid ISO date
+      expect(() => new Date(catalog.generatedAt)).not.toThrow()
+    })
+  })
+
+  describe('error handling', () => {
+    test('provides helpful error message on failure', async () => {
+      const nonExistentDir = path.join(testDir, 'does-not-exist')
+
+      const config: CatalogConfig = {
+        type: 'ui-components',
+        packageName: '@test/lib',
+        sourceDir: './src',
+        componentsDir: './src/components',
+        exportsFile: './src/index.ts',
+        outputFile: 'catalog-ui-components.json',
+        catalogVersion: '0.1.0',
+        validation: {
+          strict: true,
+          requireCategory: true,
+          requireDescription: true,
+          minDescriptionLength: 20,
+          requireWhenToUse: true,
+          requireWhenNotToUse: true,
+          minTags: 3,
+        },
+      }
+
+      await expect(service.generateForLibrary(nonExistentDir, config)).rejects.toThrow('Failed to generate catalog')
+    })
+  })
+})

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

@@ -0,0 +1,124 @@
+/**
+ * Service for generating catalog metadata files for component libraries
+ */
+
+import path from 'path'
+
+import fs from 'fs-extra'
+
+import { scanUILibrary } from '../scanners/ui-component-scanner.js'
+import { generateQualityReport } from '../utils/quality-reporter.js'
+
+import type { CatalogConfig, UiComponentCatalog, GenerationResult, UiComponent, ValidationResult } from '../types/catalog-types.js'
+
+export class CatalogGeneratorService {
+  /**
+   * Generate catalog metadata for a component library
+   *
+   * @param libraryPath - Absolute path to the library directory
+   * @param config - Validated catalog configuration
+   * @returns Generation result with success status and quality report
+   */
+  async generateForLibrary(libraryPath: string, config: CatalogConfig): Promise<GenerationResult> {
+    try {
+      // 1. Scan library components
+      const scanResult = await scanUILibrary(libraryPath, config.packageName)
+
+      // 2. Validate components
+      const validatedComponents = this.filterValidComponents(scanResult.components, config)
+
+      // 3. Extract validation results
+      const { errors, warnings } = this.categorizeValidations(scanResult.validations)
+
+      // 4. Generate quality report
+      const qualityReport = generateQualityReport(scanResult.components.length, scanResult.excluded, scanResult.validations)
+
+      // 5. Check if generation should fail (strict mode with errors)
+      if (config.validation.strict && errors.length > 0) {
+        return {
+          success: false,
+          catalogFile: '',
+          qualityReport,
+          errors,
+          warnings,
+        }
+      }
+
+      // 6. Read package version
+      const packageJson = await this.readPackageJson(libraryPath)
+
+      // 7. Create catalog
+      const catalog: UiComponentCatalog = {
+        $schema: 'https://launch77.io/schemas/catalog-ui-components.schema.json',
+        catalogType: 'ui-components',
+        catalogVersion: config.catalogVersion,
+        packageName: config.packageName,
+        packageVersion: packageJson.version,
+        generatedAt: new Date().toISOString(),
+        components: validatedComponents,
+      }
+
+      // 8. Write catalog file
+      const outputPath = path.join(libraryPath, config.outputFile)
+      await fs.writeJson(outputPath, catalog, { spaces: 2 })
+
+      return {
+        success: true,
+        catalogFile: outputPath,
+        qualityReport,
+        errors,
+        warnings,
+      }
+    } catch (error) {
+      throw new Error(`Failed to generate catalog: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Filter components that passed validation
+   */
+  private filterValidComponents(components: UiComponent[], config: CatalogConfig): UiComponent[] {
+    // In strict mode, only include components with valid metadata
+    if (config.validation.strict) {
+      return components.filter((component) => {
+        // Component is valid if it has required fields
+        return component.description && component.category
+      })
+    }
+
+    // In non-strict mode, include all components
+    return components
+  }
+
+  /**
+   * Categorize validations into errors and warnings
+   */
+  private categorizeValidations(validations: ValidationResult[]): {
+    errors: ValidationResult[]
+    warnings: ValidationResult[]
+  } {
+    const errors = validations.filter((v) => !v.valid && v.errors.length > 0)
+    const warnings = validations.filter((v) => v.warnings.length > 0)
+
+    return { errors, warnings }
+  }
+
+  /**
+   * Read package.json from library directory
+   */
+  private async readPackageJson(libraryPath: string): Promise<{ version: string }> {
+    const packageJsonPath = path.join(libraryPath, 'package.json')
+
+    if (!(await fs.pathExists(packageJsonPath))) {
+      throw new Error(`package.json not found in ${libraryPath}`)
+    }
+
+    const packageJson = await fs.readJson(packageJsonPath)
+
+    if (!packageJson.version) {
+      throw new Error(`package.json in ${libraryPath} does not have a version field`)
+    }
+
+    return packageJson
+  }
+}

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

@@ -0,0 +1,222 @@
+import * as path from 'path'
+
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import ora from 'ora'
+import prettier from 'prettier'
+
+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 { ValidationResult, UiComponent } from '../types/catalog-types.js'
+
+export interface ScanCatalogOptions {
+  strict?: boolean
+  quiet?: boolean
+}
+
+export interface ScanCatalogResult {
+  catalogPath: string
+  version: string
+  totalArtifacts: number
+}
+
+/**
+ * Catalog Service
+ *
+ * Scans Launch77 artifacts and generates catalog.json
+ */
+export class CatalogService {
+  /**
+   * Scan Launch77 codebase and generate catalog.json
+   */
+  async scanCatalog(context: MonorepoContext, 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 spinner = ora('Scanning codebase...').start()
+
+    // Phase 1: Scan all UI components deterministically (with validation)
+    const { components: uiComponents, validations, excluded } = await this.scanAllUIComponents(launch77Root)
+
+    spinner.succeed(`Found ${uiComponents.length} UI components`)
+    console.log(chalk.gray(`  • ${uiComponents.length} UI components`))
+    if (excluded > 0) {
+      console.log(chalk.gray(`  • ${excluded} excluded (@launch77-ignore)`))
+    }
+
+    // Generate quality report
+    const totalScanned = uiComponents.length + excluded
+    const qualityReport = generateQualityReport(totalScanned, excluded, validations)
+
+    // Print quality report unless in quiet mode
+    if (!quiet) {
+      printQualityReport(qualityReport, strict)
+    }
+
+    // In strict mode, fail if there are validation errors
+    if (strict && qualityReport.errors.length > 0) {
+      throw new Error('Catalog validation failed in strict mode')
+    }
+
+    console.log(chalk.blue('\n📝 Generating catalog with deterministic data...\n'))
+    console.log(chalk.green('  ✓ All required fields populated'))
+    console.log(chalk.green('  ✓ Props extracted via TypeScript AST'))
+
+    // Read existing catalog to check if content changed
+    const catalogPath = path.join(launch77Root, 'catalog.json')
+    const hasChanges = await this.catalogHasChanges(catalogPath, {
+      uiComponents,
+    })
+
+    // Get current or next version
+    const newVersion = hasChanges ? await this.getNextVersion(catalogPath) : await this.getCurrentVersion(catalogPath)
+
+    if (!hasChanges) {
+      console.log(chalk.gray('\n  ℹ No changes detected - version unchanged\n'))
+    }
+
+    // Generate examples.generated.ts files for UI libraries with examples
+    console.log(chalk.blue('\n📦 Generating examples exports...'))
+    await generateExamplesFiles(uiComponents, launch77Root)
+    console.log(chalk.green('  ✓ Generated examples.generated.ts files'))
+
+    // Build catalog object
+    const catalog = {
+      $schema: './schemas/catalog.schema.json',
+      version: newVersion,
+      description: 'Launch77 Platform Artifact Catalog - UI Components',
+      uiComponents,
+    }
+
+    // Save catalog (no AI enrichment - metadata comes from source code)
+    // Use Prettier programmatically to match pre-commit formatting
+    const prettierConfig = await prettier.resolveConfig(catalogPath)
+    const formatted = await prettier.format(JSON.stringify(catalog, null, 2), {
+      ...prettierConfig,
+      parser: 'json',
+      filepath: catalogPath,
+    })
+    await fs.writeFile(catalogPath, formatted)
+
+    console.log(chalk.blue('\n💾 Writing catalog.json...\n'))
+    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')
+
+    if (await fs.pathExists(path.dirname(marketingSiteCatalogPath))) {
+      await fs.writeFile(marketingSiteCatalogPath, formatted)
+      console.log(chalk.green(`  ✓ Synced to marketing site`))
+    }
+
+    const totalArtifacts = catalog.uiComponents.length
+
+    console.log(chalk.green(`\n✅ Done! ${totalArtifacts} UI components cataloged (version ${newVersion}).\n`))
+
+    return {
+      catalogPath,
+      version: newVersion,
+      totalArtifacts,
+    }
+  }
+
+  /**
+   * Scan all UI components from @launch77/ui and @launch/marketing-ui
+   */
+  private async scanAllUIComponents(launch77Root: string): Promise<{
+    components: UiComponent[]
+    validations: ValidationResult[]
+    excluded: number
+  }> {
+    const components: UiComponent[] = []
+    const validations: ValidationResult[] = []
+    let excluded = 0
+
+    const uiLibraries = [
+      { path: path.join(launch77Root, 'libraries/ui'), package: '@launch77/ui' },
+      { path: path.join(launch77Root, 'libraries/marketing-ui'), package: '@launch/marketing-ui' },
+    ]
+
+    for (const lib of uiLibraries) {
+      if (await fs.pathExists(lib.path)) {
+        const result = await scanUILibrary(lib.path, lib.package)
+        components.push(...result.components)
+        validations.push(...result.validations)
+        excluded += result.excluded
+      }
+    }
+
+    return { components, validations, excluded }
+  }
+
+  /**
+   * Check if catalog content has changed (excluding version field)
+   */
+  private async catalogHasChanges(
+    catalogPath: string,
+    newContent: {
+      uiComponents: UiComponent[]
+    }
+  ): Promise<boolean> {
+    if (!(await fs.pathExists(catalogPath))) {
+      return true // No existing catalog = changes
+    }
+
+    try {
+      const existingCatalog = await fs.readJson(catalogPath)
+
+      // Compare content without version fields
+      const existingContent = {
+        uiComponents: existingCatalog.uiComponents || [],
+      }
+
+      return JSON.stringify(existingContent) !== JSON.stringify(newContent)
+    } catch (error) {
+      return true // Error reading = treat as changes
+    }
+  }
+
+  /**
+   * Get current version from existing catalog
+   */
+  private async getCurrentVersion(catalogPath: string): Promise<string> {
+    if (!(await fs.pathExists(catalogPath))) {
+      return '1.0.0'
+    }
+
+    try {
+      const existingCatalog = await fs.readJson(catalogPath)
+      return existingCatalog.version || '1.0.0'
+    } catch (error) {
+      return '1.0.0'
+    }
+  }
+
+  /**
+   * Get the next version by incrementing the patch version of existing catalog
+   * If no catalog exists, start at 1.0.0
+   */
+  private async getNextVersion(catalogPath: string): Promise<string> {
+    const currentVersion = await this.getCurrentVersion(catalogPath)
+
+    // Parse version (major.minor.patch)
+    const versionParts = currentVersion.split('.')
+    const major = parseInt(versionParts[0] || '1', 10)
+    const minor = parseInt(versionParts[1] || '0', 10)
+    const patch = parseInt(versionParts[2] || '0', 10)
+
+    // Increment patch version
+    const newVersion = `${major}.${minor}.${patch + 1}`
+
+    console.log(chalk.gray(`  Version: ${chalk.white(currentVersion)} → ${chalk.white(newVersion)}\n`))
+
+    return newVersion
+  }
+}