openpets 1.0.4

package/build-pet.ts

@@ -0,0 +1,429 @@
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'fs'
+import { pathToFileURL } from 'url'
+import { PluginValidator } from './validate-pet.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const projectRoot = dirname(dirname(__dirname))
+
+const DEBUG = process.env.PETS_DEBUG === 'true'
+
+function debug(...msgs: any[]) {
+  if (DEBUG) {
+    console.log('[BUILD-PET]', ...msgs)
+  }
+}
+
+interface ToolDefinition {
+  name: string
+  description: string
+  schema: any
+}
+
+async function extractToolsFromIndexFile(indexPath: string): Promise<ToolDefinition[]> {
+  debug('=== EXTRACTING TOOLS FROM INDEX FILE ===')
+  debug('Index path:', indexPath)
+  debug('File exists:', existsSync(indexPath))
+
+  try {
+    const indexUrl = pathToFileURL(indexPath).href
+    debug('Index URL:', indexUrl)
+
+    debug('Attempting dynamic import...')
+    const indexModule = await import(/* @vite-ignore */ indexUrl)
+    debug('Import successful')
+    debug('Module keys:', Object.keys(indexModule))
+
+    if (indexModule.toolsMetadata && Array.isArray(indexModule.toolsMetadata)) {
+      console.log(`   Found ${indexModule.toolsMetadata.length} tools from exported toolsMetadata`)
+      debug('Tools metadata:', JSON.stringify(indexModule.toolsMetadata, null, 2))
+      return indexModule.toolsMetadata
+    } else {
+      debug('toolsMetadata not found or not an array')
+      debug('indexModule.toolsMetadata:', indexModule.toolsMetadata)
+    }
+  } catch (error) {
+    console.warn(`   ⚠️  Could not import toolsMetadata, falling back to file parsing`)
+    console.warn(`   Error: ${error instanceof Error ? error.message : String(error)}`)
+    debug('Import error details:', {
+      name: error instanceof Error ? error.name : 'Unknown',
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : 'No stack trace'
+    })
+  }
+
+  debug('Falling back to file parsing')
+  return extractToolsFromIndexFileByParsing(indexPath)
+}
+
+function extractToolsFromIndexFileByParsing(indexPath: string): ToolDefinition[] {
+  const content = readFileSync(indexPath, 'utf8')
+
+  const toolsMatch = content.match(/const\s+tools:\s*ToolDefinition\[\]\s*=\s*\[([\s\S]*?)\n\s*\]/m)
+  if (!toolsMatch) {
+    console.warn('⚠️  Could not find tools array in index.ts')
+    return []
+  }
+
+  const toolsArray = toolsMatch[1]
+  const toolNames: ToolDefinition[] = []
+
+  const toolsSeparated = toolsArray.split(/\n\s*\{/).filter(part => part.includes('name:'))
+  const toolBlocks = toolsSeparated.map((part, idx) => {
+    if (idx === 0) return part
+    return '{' + part
+  })
+
+  for (const block of toolBlocks) {
+    const nameMatch = block.match(/name:\s*["']([^"']+)["']/)
+    const descMatch = block.match(/description:\s*["']([^"']+)["']/)
+
+    const schemaMatch = block.match(/schema:\s*z\.object\(\{([\s\S]*?)\}\),?\s*(?:async\s+execute|$)/)
+
+    if (nameMatch && descMatch) {
+      let schemaProperties: any = {}
+
+      if (schemaMatch) {
+        const schemaContent = schemaMatch[1]
+
+        const lines = schemaContent.split('\n').filter(l => l.trim() && !l.trim().startsWith('//'))
+
+        for (const line of lines) {
+          const propMatch = line.match(/^\s*(\w+):\s*z\.(.+?),?\s*$/)
+          if (!propMatch) continue
+
+          const [, propName, zodDef] = propMatch
+          let propSchema: any = {}
+
+          if (zodDef.includes('string(')) {
+            propSchema.type = 'string'
+          } else if (zodDef.includes('number(')) {
+            propSchema.type = 'number'
+            const minMatch = zodDef.match(/\.min\((\d+)\)/)
+            const maxMatch = zodDef.match(/\.max\((\d+)\)/)
+            if (minMatch) propSchema.minimum = parseInt(minMatch[1])
+            if (maxMatch) propSchema.maximum = parseInt(maxMatch[1])
+          } else if (zodDef.includes('boolean(')) {
+            propSchema.type = 'boolean'
+          } else if (zodDef.includes('enum(')) {
+            propSchema.type = 'string'
+            const enumMatch = zodDef.match(/enum\(\[([^\]]+)\]\)/)
+            if (enumMatch) {
+              const enumValues = enumMatch[1].match(/["']([^"']+)["']/g)?.map(v => v.replace(/["']/g, ''))
+              if (enumValues) propSchema.enum = enumValues
+            }
+          } else if (zodDef.includes('array(')) {
+            propSchema.type = 'array'
+            const arrayTypeMatch = zodDef.match(/array\(z\.(\w+)\(\)\)/)
+            if (arrayTypeMatch) {
+              propSchema.items = { type: arrayTypeMatch[1].toLowerCase() }
+            }
+          }
+
+          if (zodDef.includes('.optional()')) {
+            propSchema.optional = true
+          }
+
+          const descMatch = zodDef.match(/\.describe\(["']([^"']+)["']\)/)
+          if (descMatch) {
+            propSchema.description = descMatch[1]
+          }
+
+          schemaProperties[propName] = propSchema
+        }
+      }
+
+      toolNames.push({
+        name: nameMatch[1],
+        description: descMatch[1],
+        schema: {
+          type: 'object',
+          properties: schemaProperties
+        }
+      })
+    }
+  }
+
+  console.log(`   Found ${toolNames.length} tools in index.ts`)
+  return toolNames
+}
+
+function formatZodSchema(schema: any, depth: number = 0): any {
+  if (!schema || !schema._def) {
+    return { type: 'object', properties: {} }
+  }
+
+  const def = schema._def
+  const zodType = def.typeName || def.type || schema.constructor?.name || 'unknown'
+
+  if (zodType === 'ZodObject' || zodType === 'object') {
+    const properties: any = {}
+    const shapeObj = typeof def.shape === 'function' ? def.shape() : def.shape || {}
+
+    for (const [key, value] of Object.entries(shapeObj)) {
+      properties[key] = formatZodSchema(value, depth + 1)
+    }
+
+    return {
+      type: 'object',
+      properties
+    }
+  }
+
+  if (zodType === 'ZodString' || zodType === 'string') {
+    return { type: 'string' }
+  }
+
+  if (zodType === 'ZodNumber' || zodType === 'number') {
+    const result: any = { type: 'number' }
+    if (def.checks) {
+      for (const check of def.checks) {
+        if (check.kind === 'min') result.minimum = check.value
+        if (check.kind === 'max') result.maximum = check.value
+      }
+    }
+    return result
+  }
+
+  if (zodType === 'ZodBoolean' || zodType === 'boolean') {
+    return { type: 'boolean' }
+  }
+
+  if (zodType === 'ZodArray' || zodType === 'array') {
+    return {
+      type: 'array',
+      items: formatZodSchema(def.type, depth + 1)
+    }
+  }
+
+  if (zodType === 'ZodEnum' || zodType === 'enum') {
+    let values = def.values
+    if (!values && schema._def?.values) {
+      values = schema._def.values
+    }
+    if (!values && schema.options) {
+      values = schema.options
+    }
+
+    const enumArray = Array.isArray(values) ? values : Object.values(values || {})
+    return {
+      type: 'string',
+      enum: enumArray
+    }
+  }
+
+  if (zodType === 'ZodOptional' || zodType === 'optional') {
+    return {
+      ...formatZodSchema(def.innerType, depth + 1),
+      optional: true
+    }
+  }
+
+  return { type: zodType }
+}
+
+function generateToolsMetadata(tools: ToolDefinition[]): Array<{ name: string; description: string; schema: any }> {
+  return tools.map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    schema: tool.schema._def ? formatZodSchema(tool.schema) : tool.schema
+  }))
+}
+
+function generateScriptsFromTools(tools: ToolDefinition[], petName: string): Record<string, string> {
+  const scripts: Record<string, string> = {
+    build: 'pets build',
+    'build:tsc': 'tsc',
+    quickstart: `opencode run "list available ${petName} commands"`,
+  }
+
+  for (const tool of tools) {
+    let scriptName = tool.name
+
+    if (scriptName.startsWith(`${petName}-`)) {
+      scriptName = scriptName.replace(new RegExp(`^${petName}-`), 'test:')
+    } else {
+      scriptName = `test:${scriptName}`
+    }
+
+    const command = `opencode run "${tool.description}"`
+    scripts[scriptName] = command
+  }
+
+  scripts['test:all'] = 'echo "Run individual test scripts to test specific tools"'
+
+  return scripts
+}
+
+export async function buildPet(petName?: string): Promise<void> {
+  debug('=== BUILD PET STARTING ===')
+  debug('Initial petName:', petName)
+  debug('CWD:', process.cwd())
+  debug('Project root:', projectRoot)
+
+  if (!petName) {
+    const cwd = process.cwd()
+    const petsDir = join(projectRoot, 'pets')
+
+    debug('Auto-detecting pet from CWD:', cwd)
+    debug('Pets directory:', petsDir)
+
+    if (cwd.includes('/pets/')) {
+      petName = cwd.split('/pets/')[1].split('/')[0]
+      console.log(`📦 Auto-detected pet: ${petName}`)
+      debug('Auto-detected pet:', petName)
+    }
+
+    if (!petName) {
+      console.error('Usage: pets build <pet-name>')
+      console.error('Example: pets build postgres')
+      console.error('')
+      console.error('Available pets:')
+      if (existsSync(petsDir)) {
+        const pets = readdirSync(petsDir).filter(dir => {
+          const petPath = join(petsDir, dir)
+          return statSync(petPath).isDirectory() && dir !== '_TEMPLATE_'
+        })
+        pets.forEach(pet => console.error(`  - ${pet}`))
+        debug('Available pets:', pets)
+      } else {
+        debug('Pets directory does not exist:', petsDir)
+      }
+      process.exit(1)
+    }
+  }
+
+  const petDir = join(projectRoot, 'pets', petName)
+  const packageJsonPath = join(petDir, 'package.json')
+  const indexPath = join(petDir, 'index.ts')
+
+  debug('Pet directory:', petDir)
+  debug('Package.json path:', packageJsonPath)
+  debug('Index.ts path:', indexPath)
+
+  if (!existsSync(petDir)) {
+    console.error(`❌ Pet '${petName}' not found in pets/ directory`)
+    debug('Pet directory does not exist:', petDir)
+    process.exit(1)
+  }
+
+  if (!existsSync(packageJsonPath)) {
+    console.error(`❌ package.json not found for pet '${petName}'`)
+    debug('Package.json does not exist:', packageJsonPath)
+    process.exit(1)
+  }
+
+  if (!existsSync(indexPath)) {
+    console.error(`❌ index.ts not found for pet '${petName}'`)
+    debug('Index.ts does not exist:', indexPath)
+    process.exit(1)
+  }
+
+  console.log(`🔨 Building ${petName}...`)
+  debug('All required files found, proceeding with build')
+
+  const packageJsonContent = readFileSync(packageJsonPath, 'utf8')
+  debug('Package.json content length:', packageJsonContent.length)
+  const packageJson = JSON.parse(packageJsonContent)
+  debug('Package.json parsed successfully')
+  debug('Package name:', packageJson.name)
+  debug('Package version:', packageJson.version)
+
+  // Auto-generate repository field if missing
+  if (!packageJson.repository) {
+    packageJson.repository = {
+      type: 'git',
+      url: `https://github.com/raggle-ai/pets/pets/${petName}`
+    }
+    debug('Auto-generated repository field:', packageJson.repository.url)
+  }
+
+  console.log(`   Name: ${packageJson.name}`)
+  console.log(`   Version: ${packageJson.version}`)
+  console.log(`   Description: ${packageJson.description || 'No description'}`)
+
+  console.log(`\n🔍 Validating plugin structure...`)
+  const validator = new PluginValidator()
+  const validation = validator.validatePlugin(petDir)
+
+  if (validation.result.errors.length > 0) {
+    console.log(`\n❌ Validation failed with ${validation.result.errors.length} error(s):`)
+    validation.result.errors.forEach(error => {
+      console.log(`   ❌ ${error}`)
+    })
+    console.log(`\n💥 Build aborted due to validation errors.`)
+    process.exit(1)
+  }
+
+  if (validation.result.warnings.length > 0) {
+    console.log(`\n⚠️  Found ${validation.result.warnings.length} warning(s):`)
+    validation.result.warnings.forEach(warning => {
+      console.log(`   ⚠️  ${warning}`)
+    })
+  }
+
+  if (validation.result.codePatternWarnings && validation.result.codePatternWarnings.length > 0) {
+    console.log(`\n📋 Code pattern analysis:`)
+    validation.result.codePatternWarnings.forEach(warning => {
+      console.log(`   ${warning}`)
+    })
+  }
+
+  if (validation.result.errors.length === 0 && validation.result.warnings.length === 0 && (!validation.result.codePatternWarnings || validation.result.codePatternWarnings.length === 0)) {
+    console.log(`   ✓ All validation checks passed`)
+  }
+
+  debug('Extracting tools from index file...')
+  const tools = await extractToolsFromIndexFile(indexPath)
+  debug(`Extracted ${tools.length} tools`)
+
+  if (tools.length > 0) {
+    console.log(`\n📝 Generating scripts and metadata for ${tools.length} tools...`)
+    debug('Tools extracted:', tools.map(t => t.name))
+
+    const scripts = generateScriptsFromTools(tools, petName)
+    debug('Generated scripts:', Object.keys(scripts))
+
+    const toolsMetadata = generateToolsMetadata(tools)
+    debug('Generated tools metadata count:', toolsMetadata.length)
+
+    packageJson.scripts = scripts
+    delete packageJson.tools
+
+    const commandsJsonPath = join(petDir, 'commands.json')
+    debug('Commands.json path:', commandsJsonPath)
+
+    const commandsData = {
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      tools: toolsMetadata,
+      generatedAt: new Date().toISOString()
+    }
+
+    debug('Writing package.json...')
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8')
+    debug('Package.json written successfully')
+
+    debug('Writing commands.json...')
+    writeFileSync(commandsJsonPath, JSON.stringify(commandsData, null, 2) + '\n', 'utf8')
+    debug('Commands.json written successfully')
+
+    console.log(`   ✓ Updated package.json with ${Object.keys(scripts).length} scripts`)
+    console.log(`   ✓ Generated commands.json with ${tools.length} tools`)
+
+    console.log(`\n🔧 Generated test scripts:`)
+    Object.entries(scripts).forEach(([name, cmd]) => {
+      if (name.startsWith('test:')) {
+        console.log(`   - npm run ${name}`)
+      }
+    })
+  } else {
+    debug('No tools found in index file')
+  }
+
+  console.log(`\n✅ ${petName} built successfully!`)
+  debug('=== BUILD COMPLETE ===')
+}

package/cli.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+
+import { buildPet } from './build-pet.js'
+import { deployPet } from './deploy-pet.js'
+import { addFolderToHistory } from './config-manager.js'
+import { spawn } from 'child_process'
+import { resolve } from 'path'
+import { readFileSync, existsSync } from 'fs'
+
+const args = process.argv.slice(2)
+const command = args[0]
+
+const DEBUG = process.env.PETS_DEBUG === 'true'
+
+function log(...msgs: any[]) {
+  if (DEBUG) {
+    console.log('[PETS-CLI]', ...msgs)
+  }
+}
+
+function displayInstalledPlugins() {
+  const opencodeJsonPath = resolve(process.cwd(), 'opencode.json')
+
+  log('Looking for opencode.json at:', opencodeJsonPath)
+
+  if (!existsSync(opencodeJsonPath)) {
+    log('opencode.json not found')
+    return
+  }
+
+  try {
+    const content = readFileSync(opencodeJsonPath, 'utf-8')
+    log('opencode.json content length:', content.length)
+
+    const config = JSON.parse(content)
+    log('Parsed opencode.json config:', Object.keys(config))
+
+    if (config.plugin && Array.isArray(config.plugin) && config.plugin.length > 0) {
+      const plugins = config.plugin.filter((p: string) => typeof p === 'string' && p.trim())
+      log('Found plugins:', plugins)
+
+      if (plugins.length > 0) {
+        console.log('\x1b[36m%s\x1b[0m', '📦 Installed plugins:')
+        console.log('\x1b[2m%s\x1b[0m', `   ${plugins.join(', ')}`)
+        console.log('')
+      }
+    } else {
+      log('No plugins found in config')
+    }
+  } catch (error) {
+    log('Error reading opencode.json:', error)
+  }
+}
+
+function killPort(port: number) {
+  log(`Attempting to kill processes on port ${port}`)
+  try {
+    const { execSync } = require('child_process')
+    execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { stdio: 'ignore' })
+    log(`Successfully killed processes on port ${port}`)
+  } catch (error) {
+    log(`No processes to kill on port ${port} or error occurred:`, error)
+  }
+}
+
+function launchManager() {
+  const startTime = Date.now()
+  const uiDir = resolve(__dirname, '../../apps/desktop')
+  const projectDir = process.cwd()
+
+  addFolderToHistory(projectDir)
+
+  console.log('Launching OpenPets Plugin Manager...')
+  console.log(`Project directory: ${projectDir}`)
+  console.log(`UI directory: ${uiDir}`)
+
+  log('Launch details:', {
+    __dirname,
+    uiDir,
+    projectDir,
+    uiDirExists: existsSync(uiDir),
+    timestamp: new Date().toISOString()
+  })
+
+  if (!existsSync(uiDir)) {
+    console.error(`❌ UI directory not found: ${uiDir}`)
+    log('Contents of parent directory:', require('fs').readdirSync(resolve(__dirname, '../../apps')))
+    process.exit(1)
+  }
+
+  log('Checking for package.json in UI directory')
+  const packageJsonPath = resolve(uiDir, 'package.json')
+  if (!existsSync(packageJsonPath)) {
+    console.error(`❌ package.json not found in UI directory: ${packageJsonPath}`)
+    process.exit(1)
+  }
+
+  killPort(1420)
+
+  log('Spawning npm process with tauri:dev')
+  const child = spawn('npm', ['run', 'tauri:dev'], {
+    cwd: uiDir,
+    stdio: 'inherit',
+    shell: true,
+    env: {
+      ...process.env,
+      OPENPETS_PROJECT_DIR: projectDir,
+      PETS_DEBUG: DEBUG ? 'true' : 'false'
+    }
+  })
+
+  log('Child process spawned with PID:', child.pid)
+
+  child.on('error', (error) => {
+    console.error('Failed to launch manager:', error)
+    log('Error details:', {
+      message: error.message,
+      stack: error.stack,
+      elapsed: Date.now() - startTime
+    })
+    process.exit(1)
+  })
+
+  child.on('exit', (code) => {
+    const elapsed = Date.now() - startTime
+    log(`Manager process exited with code ${code} after ${elapsed}ms`)
+    if (code !== 0) {
+      console.error(`Manager exited with code ${code}`)
+      process.exit(code || 1)
+    }
+  })
+}
+
+log('=== PETS CLI STARTUP ===')
+log('Command:', command)
+log('Args:', args)
+log('CWD:', process.cwd())
+log('ENV.OPENPETS_PROJECT_DIR:', process.env.OPENPETS_PROJECT_DIR)
+log('ENV.PETS_DEBUG:', process.env.PETS_DEBUG)
+
+displayInstalledPlugins()
+
+if (command === 'build') {
+  const petName = args[1]
+  log('Building pet:', petName)
+  buildPet(petName).catch(error => {
+    console.error('Error building pet:', error)
+    log('Build error details:', error)
+    process.exit(1)
+  })
+} else if (command === 'deploy') {
+  const petName = args[1]
+  log('Deploying pet:', petName)
+  deployPet(petName).catch(error => {
+    console.error('Error deploying pet:', error)
+    log('Deploy error details:', error)
+    process.exit(1)
+  })
+} else if (!command) {
+  log('No command provided, launching manager UI')
+  launchManager()
+} else {
+  log('Unknown command:', command)
+  console.error('Usage: pets [command] [options]')
+  console.error('')
+  console.error('Commands:')
+  console.error('  (none)             Launch the plugin manager UI (default)')
+  console.error('  build <pet-name>   Build and validate a pet package')
+  console.error('  deploy <pet-name>  Build and deploy a pet package with metadata')
+  console.error('')
+  console.error('Examples:')
+  console.error('  pets               # Launch the desktop plugin manager')
+  console.error('  pets build postgres')
+  console.error('  pets deploy maps')
+  console.error('')
+  console.error('Environment:')
+  console.error('  PETS_DEBUG=true    Enable detailed debug logging')
+  process.exit(1)
+}

package/config-manager.ts

@@ -0,0 +1,82 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+export interface PetsConfig {
+  folderHistory: Array<{
+    path: string
+    timestamp: number
+    name?: string
+  }>
+}
+
+const CONFIG_DIR = join(homedir(), '.pets')
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+const MAX_HISTORY_ITEMS = 20
+
+function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+}
+
+export function readConfig(): PetsConfig {
+  ensureConfigDir()
+
+  if (!existsSync(CONFIG_FILE)) {
+    return { folderHistory: [] }
+  }
+
+  try {
+    const content = readFileSync(CONFIG_FILE, 'utf-8')
+    return JSON.parse(content)
+  } catch (error) {
+    console.error('Error reading config file:', error)
+    return { folderHistory: [] }
+  }
+}
+
+export function writeConfig(config: PetsConfig): void {
+  ensureConfigDir()
+
+  try {
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8')
+  } catch (error) {
+    console.error('Error writing config file:', error)
+  }
+}
+
+export function addFolderToHistory(folderPath: string): void {
+  const config = readConfig()
+
+  const existingIndex = config.folderHistory.findIndex(
+    entry => entry.path === folderPath
+  )
+
+  if (existingIndex !== -1) {
+    config.folderHistory.splice(existingIndex, 1)
+  }
+
+  const folderName = folderPath.split('/').pop() || folderPath
+
+  config.folderHistory.unshift({
+    path: folderPath,
+    timestamp: Date.now(),
+    name: folderName
+  })
+
+  if (config.folderHistory.length > MAX_HISTORY_ITEMS) {
+    config.folderHistory = config.folderHistory.slice(0, MAX_HISTORY_ITEMS)
+  }
+
+  writeConfig(config)
+}
+
+export function getFolderHistory(): PetsConfig['folderHistory'] {
+  const config = readConfig()
+  return config.folderHistory
+}
+
+export function clearFolderHistory(): void {
+  writeConfig({ folderHistory: [] })
+}