openpets 1.0.5 → 1.0.7

package/validate-pet.ts

@@ -1,749 +0,0 @@
-import { readFileSync, existsSync } from 'fs'
-import { join } from 'path'
-import { execSync } from 'child_process'
-
-export interface ValidationResult {
-  valid: boolean
-  errors: string[]
-  warnings: string[]
-  codePatternWarnings?: string[]
-}
-
-export interface PackageValidation {
-  name: string
-  path: string
-  result: ValidationResult
-  usesModernPattern?: boolean
-  usesPluginFactory?: boolean
-}
-
-export interface ValidationReport {
-  total: number
-  passed: number
-  failed: number
-  details: PackageValidation[]
-}
-
-export class PluginValidator {
-  private requiredFields = [
-    'name',
-    'version',
-    'title',
-    'subtitle',
-    'description',
-    'main',
-    'types',
-    'keywords',
-    'dependencies',
-    'queries',
-    'scenarios'
-  ]
-
-  private recommendedFields = [
-    'providers'
-  ]
-
-  private requiredScripts = [
-    'test:all'
-  ]
-
-  validatePlugin(pluginPath: string): PackageValidation {
-    const packageJsonPath = join(pluginPath, 'package.json')
-
-    if (!existsSync(packageJsonPath)) {
-      return {
-        name: this.getFolderName(pluginPath),
-        path: pluginPath,
-        result: {
-          valid: false,
-          errors: ['package.json not found'],
-          warnings: []
-        }
-      }
-    }
-
-    try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
-      const result = this.validatePackageJson(packageJson, pluginPath)
-
-      const codePatternAnalysis = this.analyzeCodePatterns(pluginPath)
-
-      return {
-        name: packageJson.name || this.getFolderName(pluginPath),
-        path: pluginPath,
-        result: {
-          ...result,
-          codePatternWarnings: codePatternAnalysis.warnings
-        },
-        usesModernPattern: codePatternAnalysis.usesModernPattern,
-        usesPluginFactory: codePatternAnalysis.usesPluginFactory
-      }
-    } catch (error) {
-      return {
-        name: this.getFolderName(pluginPath),
-        path: pluginPath,
-        result: {
-          valid: false,
-          errors: [`Invalid JSON in package.json: ${error instanceof Error ? error.message : String(error)}`],
-          warnings: []
-        }
-      }
-    }
-  }
-
-  private validatePackageJson(pkg: any, pluginPath: string): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    // Check schema reference
-    const validSchemas = [
-      '../../src/shared-utils/opencode-plugin.schema.json',
-      'https://pets.studio/config.json'
-    ]
-    if (!pkg.$schema || !validSchemas.includes(pkg.$schema)) {
-      errors.push('Missing or incorrect schema reference. Expected: "../../src/shared-utils/opencode-plugin.schema.json" or "https://pets.studio/config.json"')
-    }
-
-    // Check required fields
-    for (const field of this.requiredFields) {
-      if (!pkg[field]) {
-        errors.push(`Missing required field: ${field}`)
-      }
-    }
-
-    // Validate name format
-    if (pkg.name && !this.isValidPluginName(pkg.name)) {
-      errors.push(`Invalid plugin name format. Should be 'openpets/plugin-name'`)
-    }
-
-    // Validate keywords
-    if (pkg.keywords) {
-      if (!Array.isArray(pkg.keywords)) {
-        errors.push('keywords must be an array')
-      } else {
-        const requiredKeywords = ['opencode', 'plugin']
-        for (const keyword of requiredKeywords) {
-          if (!pkg.keywords.includes(keyword)) {
-            warnings.push(`Missing recommended keyword: ${keyword}`)
-          }
-        }
-      }
-    }
-
-    // Validate repository
-    if (pkg.repository) {
-      if (!pkg.repository.type || !pkg.repository.url) {
-        errors.push('repository must have type and url fields')
-      }
-    }
-
-    // Validate dependencies - @opencode-ai/plugin should only be in shared-utils
-    if (pkg.dependencies && pkg.dependencies['@opencode-ai/plugin']) {
-      errors.push('@opencode-ai/plugin should only be in shared-utils, not in individual pets')
-    }
-
-    if (pkg.peerDependencies && pkg.peerDependencies['@opencode-ai/plugin']) {
-      errors.push('@opencode-ai/plugin should only be in shared-utils, not in individual pets')
-    }
-
-    // Check for required @opencode/shared-utils dependency
-    if (!pkg.dependencies || !pkg.dependencies['@opencode/shared-utils']) {
-      errors.push('Missing required dependency "@opencode/shared-utils"')
-    }
-
-    // Validate scripts
-    if (pkg.scripts) {
-      for (const script of this.requiredScripts) {
-        if (!pkg.scripts[script]) {
-          warnings.push(`Missing recommended script: ${script}`)
-        }
-      }
-    } else {
-      warnings.push('No scripts defined - consider adding test scripts')
-    }
-
-    // Validate providers structure if present
-    const validProviderIds = new Set<string>()
-    if (pkg.providers) {
-      const providersValidation = this.validateProviders(pkg.providers)
-      errors.push(...providersValidation.errors)
-      warnings.push(...providersValidation.warnings)
-
-      if (Array.isArray(pkg.providers)) {
-        pkg.providers.forEach((provider: any) => {
-          if (provider.id) {
-            validProviderIds.add(provider.id)
-          }
-        })
-      }
-    } else if (pkg.envVariables) {
-      warnings.push('Missing recommended field "providers" - consider defining providers with credentialsUrl for better documentation')
-    }
-
-    // Validate envVariables structure if present
-    if (pkg.envVariables) {
-      const envValidation = this.validateEnvVariables(pkg.envVariables, validProviderIds)
-      errors.push(...envValidation.errors)
-      warnings.push(...envValidation.warnings)
-    }
-
-    // Validate queries (required)
-    if (!pkg.queries) {
-      errors.push('Missing required field: queries')
-    } else {
-      if (!Array.isArray(pkg.queries)) {
-        errors.push('queries must be an array')
-      } else if (pkg.queries.length === 0) {
-        errors.push('queries array cannot be empty - add at least one example query')
-      } else {
-        // Validate each query is a non-empty string
-        pkg.queries.forEach((query: any, index: number) => {
-          if (typeof query !== 'string' || query.trim().length === 0) {
-            errors.push(`queries[${index}] must be a non-empty string`)
-          }
-        })
-      }
-    }
-
-    // Validate scenarios (required)
-    if (!pkg.scenarios) {
-      errors.push('Missing required field: scenarios')
-    } else {
-      const scenarioValidation = this.validateScenarios(pkg.scenarios)
-      if (Object.keys(pkg.scenarios).length === 0) {
-        errors.push('scenarios object cannot be empty - add at least one test scenario')
-      }
-      errors.push(...scenarioValidation.errors)
-      warnings.push(...scenarioValidation.warnings)
-    }
-
-    // Check for essential files
-    const essentialFiles = ['index.ts', 'opencode.json']
-    for (const file of essentialFiles) {
-      if (!existsSync(join(pluginPath, file))) {
-        errors.push(`Missing essential file: ${file}`)
-      }
-    }
-
-    // Check for .env.example
-    if (pkg.envVariables && !existsSync(join(pluginPath, '.env.example'))) {
-      errors.push('envVariables defined but .env.example file missing - create this file to document required environment variables')
-    } else if (pkg.envVariables && existsSync(join(pluginPath, '.env.example'))) {
-      const envExampleValidation = this.validateEnvExampleFile(join(pluginPath, '.env.example'), pkg.envVariables, pkg.providers)
-      warnings.push(...envExampleValidation.warnings)
-    }
-
-    // Check for README
-    if (!existsSync(join(pluginPath, 'README.md'))) {
-      warnings.push('README.md file missing')
-    }
-
-    // Validate optional but recommended metadata fields
-    this.validateOptionalMetadata(pkg, pluginPath, warnings, errors)
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    }
-  }
-
-  private validateProviders(providers: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    if (!Array.isArray(providers)) {
-      errors.push('providers must be an array')
-      return { valid: false, errors, warnings }
-    }
-
-    if (providers.length === 0) {
-      warnings.push('providers array is empty - add at least one provider definition')
-      return { valid: true, errors, warnings }
-    }
-
-    const seenIds = new Set<string>()
-
-    providers.forEach((provider: any, index: number) => {
-      if (typeof provider !== 'object' || provider === null) {
-        errors.push(`providers[${index}] must be an object`)
-        return
-      }
-
-      if (!provider.id) {
-        errors.push(`providers[${index}] missing required field "id"`)
-      } else if (typeof provider.id !== 'string') {
-        errors.push(`providers[${index}].id must be a string`)
-      } else {
-        if (seenIds.has(provider.id)) {
-          errors.push(`providers[${index}] duplicate provider id "${provider.id}"`)
-        }
-        seenIds.add(provider.id)
-      }
-
-      if (!provider.name) {
-        warnings.push(`providers[${index}] missing recommended field "name"`)
-      } else if (typeof provider.name !== 'string') {
-        errors.push(`providers[${index}].name must be a string`)
-      }
-
-      if (!provider.credentialsUrl) {
-        warnings.push(`providers[${index}] missing recommended field "credentialsUrl" for API key generation link`)
-      } else if (typeof provider.credentialsUrl !== 'string') {
-        errors.push(`providers[${index}].credentialsUrl must be a string`)
-      } else {
-        try {
-          new URL(provider.credentialsUrl.replace(/\{[^}]+\}/g, 'placeholder'))
-        } catch {
-          warnings.push(`providers[${index}].credentialsUrl should be a valid URL pattern`)
-        }
-      }
-
-      if (provider.credentialsDocUrl && typeof provider.credentialsDocUrl !== 'string') {
-        errors.push(`providers[${index}].credentialsDocUrl must be a string`)
-      } else if (provider.credentialsDocUrl) {
-        try {
-          new URL(provider.credentialsDocUrl)
-        } catch {
-          warnings.push(`providers[${index}].credentialsDocUrl should be a valid URL`)
-        }
-      }
-    })
-
-    return { valid: errors.length === 0, errors, warnings }
-  }
-
-  private validateEnvVariables(envVars: any, validProviderIds: Set<string>): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    if (!envVars.required && !envVars.optional) {
-      warnings.push('envVariables defined but no required or optional sections found')
-      return { valid: true, errors, warnings }
-    }
-
-    const validateVarArray = (vars: any[], type: string) => {
-      if (!Array.isArray(vars)) {
-        errors.push(`envVariables.${type} must be an array`)
-        return
-      }
-
-      vars.forEach((envVar, index) => {
-        if (!envVar.name) {
-          errors.push(`envVariables.${type}[${index}] missing name field`)
-        }
-        if (!envVar.description) {
-          warnings.push(`envVariables.${type}[${index}] missing description field`)
-        }
-        if (!envVar.providerId) {
-          warnings.push(`envVariables.${type}[${index}] missing providerId field - should reference a provider in the providers array`)
-        } else if (typeof envVar.providerId === 'string') {
-          if (validProviderIds.size > 0 && !validProviderIds.has(envVar.providerId)) {
-            errors.push(`envVariables.${type}[${index}].providerId "${envVar.providerId}" does not match any provider id in the providers array`)
-          }
-        } else {
-          errors.push(`envVariables.${type}[${index}].providerId must be a string`)
-        }
-        if (typeof envVar.priority !== 'number') {
-          warnings.push(`envVariables.${type}[${index}] missing or invalid priority field`)
-        }
-      })
-    }
-
-    if (envVars.required) {
-      validateVarArray(envVars.required, 'required')
-    }
-    if (envVars.optional) {
-      validateVarArray(envVars.optional, 'optional')
-    }
-
-    return { valid: errors.length === 0, errors, warnings }
-  }
-
-  private validateEnvExampleFile(envExamplePath: string, envVars: any, providers: any[]): { warnings: string[] } {
-    const warnings: string[] = []
-
-    try {
-      const envExampleContent = readFileSync(envExamplePath, 'utf-8')
-      const envExampleLines = envExampleContent.split('\n')
-
-      const documentedVars = new Set<string>()
-      const providerComments = new Map<string, boolean>()
-
-      for (let i = 0; i < envExampleLines.length; i++) {
-        const line = envExampleLines[i].trim()
-
-        if (line.startsWith('#') && (line.includes('http://') || line.includes('https://'))) {
-          const nextLine = envExampleLines[i + 1]?.trim()
-          if (nextLine && nextLine.includes('=')) {
-            const varName = nextLine.split('=')[0].trim()
-            providerComments.set(varName, true)
-          }
-        }
-
-        if (line && !line.startsWith('#') && line.includes('=')) {
-          const varName = line.split('=')[0].trim()
-          documentedVars.add(varName)
-        }
-      }
-
-      const allEnvVars: any[] = [
-        ...(envVars.required || []),
-        ...(envVars.optional || [])
-      ]
-
-      const providerMap = new Map<string, any>()
-      if (providers && Array.isArray(providers)) {
-        providers.forEach(provider => {
-          if (provider.id) {
-            providerMap.set(provider.id, provider)
-          }
-        })
-      }
-
-      for (const envVar of allEnvVars) {
-        if (!documentedVars.has(envVar.name)) {
-          warnings.push(`Environment variable "${envVar.name}" defined in package.json but not found in .env.example`)
-        } else if (!providerComments.has(envVar.name) && envVar.providerId) {
-          const provider = providerMap.get(envVar.providerId)
-          if (provider && provider.credentialsUrl) {
-            warnings.push(`Environment variable "${envVar.name}" in .env.example missing comment with provider credentialsUrl (${provider.credentialsUrl})`)
-          }
-        }
-      }
-
-    } catch (error) {
-      warnings.push(`Could not validate .env.example file: ${error instanceof Error ? error.message : String(error)}`)
-    }
-
-    return { warnings }
-  }
-
-  private validateScenarios(scenarios: any): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    if (typeof scenarios !== 'object') {
-      errors.push('scenarios must be an object')
-      return { valid: false, errors, warnings }
-    }
-
-    Object.entries(scenarios).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        // Array of commands - validate each is a non-empty string
-        value.forEach((cmd, index) => {
-          if (typeof cmd !== 'string' || cmd.trim().length === 0) {
-            errors.push(`scenarios.${key}[${index}] must be a non-empty string`)
-          }
-        })
-      } else if (typeof value === 'string') {
-        // Single command string
-        if (value.trim().length === 0) {
-          errors.push(`scenarios.${key} must be a non-empty string`)
-        }
-      } else {
-        errors.push(`scenarios.${key} must be a string or array of strings`)
-      }
-    })
-
-    if (Object.keys(scenarios).length === 0) {
-      warnings.push('scenarios object is empty - consider adding test scenarios')
-    }
-
-    return { valid: errors.length === 0, errors, warnings }
-  }
-
-  private validateOptionalMetadata(pkg: any, pluginPath: string, warnings: string[], errors: string[]): void {
-    const hasIcon = pkg.icon && typeof pkg.icon === 'string'
-    const hasHomeWebsite = pkg.homepage && typeof pkg.homepage === 'string'
-
-    if (!hasIcon && !hasHomeWebsite) {
-      warnings.push('Missing both "icon" and "homepage" fields - provide at least one for visual representation (icon: "assets/icon.png" or homepage for favicon fallback)')
-    } else if (hasIcon && pkg.icon.includes('assets/')) {
-      const iconPath = join(pluginPath, pkg.icon)
-      if (!existsSync(iconPath)) {
-        warnings.push(`icon file not found at path: ${pkg.icon}`)
-      }
-    }
-
-    if (!pkg.categories) {
-      warnings.push('Missing optional field "categories" - should be an array of category strings (e.g., ["productivity", "developer-tools"])')
-    } else if (!Array.isArray(pkg.categories)) {
-      errors.push('categories must be an array')
-    } else if (pkg.categories.length === 0) {
-      warnings.push('categories array is empty - add at least one category')
-    }
-
-    const hasProviders = pkg.providers && Array.isArray(pkg.providers) && pkg.providers.length > 0
-
-    if (!pkg.homepage) {
-      if (!hasProviders) {
-        warnings.push('Missing optional field "homepage" - should be a URL to the original website/service this plugin integrates with')
-      }
-    } else if (typeof pkg.homepage === 'string') {
-      try {
-        new URL(pkg.homepage)
-      } catch {
-        errors.push('homepage must be a valid URL')
-      }
-    }
-
-    if (!pkg.faq) {
-      warnings.push('Missing optional field "faq" - should be an array of FAQ items with "question" and "answer" attributes')
-    } else if (!Array.isArray(pkg.faq)) {
-      errors.push('faq must be an array')
-    } else {
-      pkg.faq.forEach((item: any, index: number) => {
-        if (typeof item !== 'object' || item === null) {
-          errors.push(`faq[${index}] must be an object with "question" and "answer" fields`)
-        } else {
-          if (!item.question || typeof item.question !== 'string') {
-            errors.push(`faq[${index}] missing or invalid "question" field`)
-          }
-          if (!item.answer || typeof item.answer !== 'string') {
-            errors.push(`faq[${index}] missing or invalid "answer" field`)
-          }
-        }
-      })
-    }
-
-    if (pkg.commands) {
-      if (!Array.isArray(pkg.commands)) {
-        errors.push('commands must be an array')
-      } else {
-        pkg.commands.forEach((command: any, index: number) => {
-          if (typeof command !== 'object' || command === null) {
-            errors.push(`commands[${index}] must be an object`)
-            return
-          }
-
-          if (!command.name || typeof command.name !== 'string') {
-            errors.push(`commands[${index}] missing or invalid "name" field`)
-          }
-          if (!command.title || typeof command.title !== 'string') {
-            errors.push(`commands[${index}] missing or invalid "title" field`)
-          }
-          if (!command.description || typeof command.description !== 'string') {
-            errors.push(`commands[${index}] missing or invalid "description" field`)
-          }
-
-          if (command.arguments !== undefined) {
-            if (!Array.isArray(command.arguments)) {
-              errors.push(`commands[${index}].arguments must be an array`)
-            } else {
-              command.arguments.forEach((arg: any, argIndex: number) => {
-                if (typeof arg !== 'object' || arg === null) {
-                  errors.push(`commands[${index}].arguments[${argIndex}] must be an object`)
-                  return
-                }
-                if (!arg.name || typeof arg.name !== 'string') {
-                  errors.push(`commands[${index}].arguments[${argIndex}] missing or invalid "name" field`)
-                }
-                if (!arg.placeholder || typeof arg.placeholder !== 'string') {
-                  errors.push(`commands[${index}].arguments[${argIndex}] missing or invalid "placeholder" field`)
-                }
-                if (!arg.type || typeof arg.type !== 'string') {
-                  errors.push(`commands[${index}].arguments[${argIndex}] missing or invalid "type" field`)
-                }
-              })
-            }
-          }
-        })
-      }
-    }
-
-    if (!pkg.envVariables) {
-      warnings.push('Missing optional field "envVariables" - consider documenting required environment variables with "required" and "optional" arrays')
-    }
-  }
-
-  private isValidPluginName(name: string): boolean {
-    return /^openpets\/[a-z0-9-]+$/.test(name)
-  }
-
-  private getFolderName(path: string): string {
-    return path.split('/').pop() || 'unknown'
-  }
-
-  validatePluginByName(pluginName: string, petsDirectory: string): PackageValidation {
-    const pluginPath = join(petsDirectory, pluginName)
-    return this.validatePlugin(pluginPath)
-  }
-
-  validateAllPlugins(petsDirectory: string): ValidationReport {
-    const plugins = this.getPluginDirectories(petsDirectory)
-    const details: PackageValidation[] = []
-
-    for (const pluginPath of plugins) {
-      const validation = this.validatePlugin(pluginPath)
-      details.push(validation)
-    }
-
-    const passed = details.filter(d => d.result.valid).length
-    const failed = details.filter(d => !d.result.valid).length
-
-    return {
-      total: details.length,
-      passed,
-      failed,
-      details
-    }
-  }
-
-  private getPluginDirectories(petsDirectory: string): string[] {
-    try {
-      const result = execSync(`find "${petsDirectory}" -maxdepth 1 -type d -not -name ".*" | sort`, {
-        encoding: 'utf-8'
-      })
-        .split('\n')
-        .filter(dir => dir.trim() && dir !== petsDirectory)
-
-      return result
-    } catch (error) {
-      console.error(`Error reading pets directory: ${error}`)
-      return []
-    }
-  }
-
-  private analyzeCodePatterns(pluginPath: string): {
-    usesModernPattern: boolean
-    usesPluginFactory: boolean
-    warnings: string[]
-  } {
-    const indexPath = join(pluginPath, 'index.ts')
-    const warnings: string[] = []
-
-    if (!existsSync(indexPath)) {
-      return { usesModernPattern: false, usesPluginFactory: false, warnings }
-    }
-
-    try {
-      const code = readFileSync(indexPath, 'utf-8')
-
-      const hasToolImport = /import\s+(?:type\s+)?{\s*[^}]*tool[^}]*}\s+from\s+['"]@opencode-ai\/plugin['"]/.test(code)
-      const hasZodImport = /import.*zod/.test(code)
-      const usesToolBuilder = /tool\s*\(\s*{/.test(code)
-      const usesInputSchema = /inputSchema\s*:\s*{/.test(code)
-      const usesPluginFactory = /createPlugin|createSingleTool/.test(code) ||
-                               /from\s+['"].*plugin-factory['"]/.test(code)
-
-      const usesModernPattern = hasZodImport && usesPluginFactory && !usesInputSchema
-
-      if (usesInputSchema && !usesToolBuilder) {
-        warnings.push('⚠️  LEGACY PATTERN: Uses inputSchema instead of Zod schema')
-      }
-
-      if (!hasZodImport && usesInputSchema) {
-        warnings.push('⚠️  LEGACY PATTERN: Missing Zod import for type-safe schemas')
-      }
-
-      if (!usesPluginFactory) {
-        warnings.push('❌ Must use plugin-factory (createPlugin/createSingleTool) - direct tool() usage is not supported')
-      }
-
-      // Check for problematic nested schema patterns
-      const nestedSchemaPatterns = this.detectNestedSchemas(code)
-      if (nestedSchemaPatterns.length > 0) {
-        warnings.push('❌ SCHEMA ERROR: Detected unsupported nested schema patterns:')
-        nestedSchemaPatterns.forEach(pattern => {
-          warnings.push(`   ${pattern}`)
-        })
-        warnings.push('   Use JSON strings instead. See src/core/plugin-factory.ts for details.')
-      }
-
-      return {
-        usesModernPattern,
-        usesPluginFactory,
-        warnings
-      }
-    } catch (error) {
-      warnings.push(`Error analyzing code patterns: ${error instanceof Error ? error.message : String(error)}`)
-      return { usesModernPattern: false, usesPluginFactory: false, warnings }
-    }
-  }
-
-  private detectNestedSchemas(code: string): string[] {
-    const problems: string[] = []
-
-    // Check for z.array(z.object({...}))
-    if (/z\.array\s*\(\s*z\.object\s*\(/.test(code)) {
-      problems.push('z.array(z.object({...})) - nested object in array')
-    }
-
-    // Check for z.object({ field: z.object({...}) })
-    if (/z\.object\s*\(\s*\{[^}]*:\s*z\.object\s*\(/.test(code)) {
-      problems.push('z.object({ nested: z.object({...}) }) - nested object in object')
-    }
-
-    // Check for z.record(...)
-    if (/z\.record\s*\(/.test(code)) {
-      problems.push('z.record(...) - record types are not supported')
-    }
-
-    // Check for z.union with objects
-    if (/z\.union\s*\(\s*\[[^\]]*z\.object/.test(code)) {
-      problems.push('z.union([z.object({...}), ...]) - union with complex types')
-    }
-
-    // Check for z.discriminatedUnion
-    if (/z\.discriminatedUnion\s*\(/.test(code)) {
-      problems.push('z.discriminatedUnion(...) - discriminated unions not supported')
-    }
-
-    return problems
-  }
-
-  printReport(report: ValidationReport): void {
-    console.log('\n🔍 Pets Plugin Validation Report')
-    console.log('==================================')
-    console.log(`Total plugins: ${report.total}`)
-    console.log(`✅ Passed: ${report.passed}`)
-    console.log(`❌ Failed: ${report.failed}`)
-    console.log('')
-
-    const modernCount = report.details.filter(d => d.usesModernPattern).length
-    const legacyCount = report.details.filter(d => !d.usesModernPattern).length
-
-    console.log('📊 Code Pattern Analysis:')
-    console.log(`   ✅ Modern pattern (plugin-factory + Zod): ${modernCount}`)
-    console.log(`   ⚠️  Legacy pattern (inputSchema): ${legacyCount}`)
-    console.log('')
-
-    for (const detail of report.details) {
-      const status = detail.result.valid ? '✅' : '❌'
-      const patternBadge = detail.usesModernPattern ? '🆕' : '⏳'
-      console.log(`${status} ${patternBadge} ${detail.name}`)
-
-      if (detail.result.errors.length > 0) {
-        detail.result.errors.forEach(error => {
-          console.log(`   ❌ ${error}`)
-        })
-      }
-
-      if (detail.result.warnings.length > 0) {
-        detail.result.warnings.forEach(warning => {
-          console.log(`   ⚠️  ${warning}`)
-        })
-      }
-
-      if (detail.result.codePatternWarnings && detail.result.codePatternWarnings.length > 0) {
-        detail.result.codePatternWarnings.forEach(warning => {
-          console.log(`   ${warning}`)
-        })
-      }
-
-      console.log('')
-    }
-
-    console.log('==================================')
-    if (report.failed === 0) {
-      console.log('🎉 All plugins passed validation!')
-    } else {
-      console.log(`💥 ${report.failed} plugin(s) failed validation. Please fix the errors above.`)
-    }
-
-    if (legacyCount > 0) {
-      console.log(`\n💡 Tip: ${legacyCount} plugin(s) use legacy patterns. Consider migrating to plugin-factory + Zod.`)
-    }
-  }
-}