openpets 1.0.4 → 1.0.6

package/cli.ts

@@ -1,179 +0,0 @@
-#!/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

@@ -1,82 +0,0 @@
-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: [] })
-}

package/deploy-pet.ts

@@ -1,91 +0,0 @@
-import { join, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import { existsSync, readdirSync, readFileSync, writeFileSync, statSync, mkdirSync } from 'fs'
-import { buildPet } from './build-pet.js'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const projectRoot = dirname(dirname(__dirname))
-
-interface PetData {
-  name: string
-  version: string
-  description: string
-  source_code_url: string
-  [key: string]: any
-}
-
-export async function deployPet(petName?: string): Promise<void> {
-  if (!petName) {
-    const cwd = process.cwd()
-    const petsDir = join(projectRoot, 'pets')
-
-    if (cwd.includes('/pets/')) {
-      petName = cwd.split('/pets/')[1].split('/')[0]
-      console.log(`📦 Auto-detected pet: ${petName}`)
-    }
-
-    if (!petName) {
-      console.error('Usage: pets deploy <pet-name>')
-      console.error('Example: pets deploy 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}`))
-      }
-      process.exit(1)
-    }
-  }
-
-  console.log(`🚀 Deploying ${petName}...`)
-
-  await buildPet(petName)
-
-  const petDir = join(projectRoot, 'pets', petName)
-  const packageJsonPath = join(petDir, 'package.json')
-
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
-
-  const sourceCodeUrl = `https://github.com/raggle-ai/pets/tree/main/pets/${petName}`
-
-  const fieldsToExclude = ['$schema', 'version', 'main', 'types', 'scripts', 'license', 'repository', 'dependencies', 'author', 'utils', 'devDependencies']
-
-  const filteredData = Object.keys(packageJson).reduce((acc, key) => {
-    if (!fieldsToExclude.includes(key)) {
-      acc[key] = packageJson[key]
-    }
-    return acc
-  }, {} as Record<string, any>)
-
-  const petData = {
-    ...filteredData,
-    name: packageJson.name,
-    version: packageJson.version,
-    description: packageJson.description,
-    source_code_url: sourceCodeUrl,
-  } as PetData
-
-  const dataDir = join(projectRoot, 'data')
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true })
-  }
-
-  const petsJsonPath = join(dataDir, 'pets.json')
-  let petsData: Record<string, PetData> = {}
-
-  if (existsSync(petsJsonPath)) {
-    petsData = JSON.parse(readFileSync(petsJsonPath, 'utf8'))
-  }
-
-  petsData[packageJson.name] = petData
-
-  writeFileSync(petsJsonPath, JSON.stringify(petsData, null, 2), 'utf8')
-
-  console.log(`✅ ${petName} deployed successfully!`)
-  console.log(`   Source URL: ${sourceCodeUrl}`)
-  console.log(`   Data saved to: ${petsJsonPath}`)
-}

package/index.ts

@@ -1,10 +0,0 @@
-export * from './plugin-factory'
-export * from './schema-helpers'
-export * from './validate-pet'
-export * from './pets-registry'
-export * from './build-pet'
-export * from './types'
-export * from './ai-client-base'
-export * from './search-pets'
-export * from './logger'
-export * from './local-cache'

package/local-cache.ts

@@ -1,280 +0,0 @@
-export interface CacheEntry<T> {
-  data: T
-  timestamp: number
-  hits: number
-}
-
-export interface CacheStats {
-  hits: number
-  misses: number
-  size: number
-  oldestEntry?: number
-  newestEntry?: number
-}
-
-export interface CacheConfig {
-  ttl?: number
-  maxSize?: number
-  cleanupInterval?: number
-}
-
-export class LocalCache<T = any> {
-  private cache: Map<string, CacheEntry<T>> = new Map()
-  private stats = { hits: 0, misses: 0 }
-  private ttl: number
-  private maxSize: number
-  private cleanupInterval: number | null
-  private cleanupTimer: NodeJS.Timeout | null = null
-
-  constructor(config: CacheConfig = {}) {
-    this.ttl = config.ttl || 3600000
-    this.maxSize = config.maxSize || 1000
-    this.cleanupInterval = config.cleanupInterval || null
-
-    if (this.cleanupInterval) {
-      this.startCleanup()
-    }
-  }
-
-  private startCleanup(): void {
-    if (this.cleanupInterval) {
-      this.cleanupTimer = setInterval(() => {
-        this.cleanup()
-      }, this.cleanupInterval)
-    }
-  }
-
-  private stopCleanup(): void {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer)
-      this.cleanupTimer = null
-    }
-  }
-
-  get(key: string): T | null {
-    const entry = this.cache.get(key)
-
-    if (!entry) {
-      this.stats.misses++
-      return null
-    }
-
-    const now = Date.now()
-    if (now - entry.timestamp > this.ttl) {
-      this.cache.delete(key)
-      this.stats.misses++
-      return null
-    }
-
-    entry.hits++
-    this.stats.hits++
-    return entry.data
-  }
-
-  set(key: string, data: T): void {
-    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-      this.evictOldest()
-    }
-
-    this.cache.set(key, {
-      data,
-      timestamp: Date.now(),
-      hits: 0
-    })
-  }
-
-  has(key: string): boolean {
-    const entry = this.cache.get(key)
-    if (!entry) return false
-
-    const now = Date.now()
-    if (now - entry.timestamp > this.ttl) {
-      this.cache.delete(key)
-      return false
-    }
-
-    return true
-  }
-
-  delete(key: string): boolean {
-    return this.cache.delete(key)
-  }
-
-  clear(): void {
-    this.cache.clear()
-    this.stats = { hits: 0, misses: 0 }
-  }
-
-  cleanup(): number {
-    const now = Date.now()
-    let removed = 0
-
-    for (const [key, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > this.ttl) {
-        this.cache.delete(key)
-        removed++
-      }
-    }
-
-    return removed
-  }
-
-  private evictOldest(): void {
-    let oldestKey: string | null = null
-    let oldestTime = Infinity
-
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp
-        oldestKey = key
-      }
-    }
-
-    if (oldestKey) {
-      this.cache.delete(oldestKey)
-    }
-  }
-
-  getStats(): CacheStats {
-    const entries = Array.from(this.cache.values())
-    const timestamps = entries.map(e => e.timestamp)
-
-    return {
-      hits: this.stats.hits,
-      misses: this.stats.misses,
-      size: this.cache.size,
-      oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : undefined,
-      newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : undefined
-    }
-  }
-
-  keys(): string[] {
-    return Array.from(this.cache.keys())
-  }
-
-  values(): T[] {
-    return Array.from(this.cache.values()).map(entry => entry.data)
-  }
-
-  entries(): Array<[string, T]> {
-    return Array.from(this.cache.entries()).map(([key, entry]) => [key, entry.data])
-  }
-
-  getHitRate(): number {
-    const total = this.stats.hits + this.stats.misses
-    return total === 0 ? 0 : this.stats.hits / total
-  }
-
-  destroy(): void {
-    this.stopCleanup()
-    this.clear()
-  }
-}
-
-export class SingleValueCache<T = any> {
-  private data: T | null = null
-  private timestamp: number = 0
-  private ttl: number
-  private hits: number = 0
-  private misses: number = 0
-
-  constructor(config: { ttl?: number } = {}) {
-    this.ttl = config.ttl || 3600000
-  }
-
-  get(): T | null {
-    if (!this.data) {
-      this.misses++
-      return null
-    }
-
-    const now = Date.now()
-    if (now - this.timestamp > this.ttl) {
-      this.data = null
-      this.misses++
-      return null
-    }
-
-    this.hits++
-    return this.data
-  }
-
-  set(data: T): void {
-    this.data = data
-    this.timestamp = Date.now()
-  }
-
-  has(): boolean {
-    if (!this.data) return false
-
-    const now = Date.now()
-    if (now - this.timestamp > this.ttl) {
-      this.data = null
-      return false
-    }
-
-    return true
-  }
-
-  clear(): void {
-    this.data = null
-    this.timestamp = 0
-  }
-
-  getAge(): number {
-    if (!this.data) return -1
-    return Date.now() - this.timestamp
-  }
-
-  getStats(): { hits: number; misses: number; hasData: boolean; age: number } {
-    return {
-      hits: this.hits,
-      misses: this.misses,
-      hasData: this.has(),
-      age: this.getAge()
-    }
-  }
-
-  getHitRate(): number {
-    const total = this.hits + this.misses
-    return total === 0 ? 0 : this.hits / total
-  }
-}
-
-export async function withCache<T>(
-  cache: LocalCache<T> | SingleValueCache<T>,
-  key: string | null,
-  fetcher: () => Promise<T>
-): Promise<T> {
-  if (cache instanceof SingleValueCache) {
-    const cached = cache.get()
-    if (cached !== null) {
-      return cached
-    }
-
-    const data = await fetcher()
-    cache.set(data)
-    return data
-  }
-
-  if (key === null) {
-    throw new Error('Key is required for LocalCache')
-  }
-
-  const cached = cache.get(key)
-  if (cached !== null) {
-    return cached
-  }
-
-  const data = await fetcher()
-  cache.set(key, data)
-  return data
-}
-
-export function createCache<T = any>(config: CacheConfig = {}): LocalCache<T> {
-  return new LocalCache<T>(config)
-}
-
-export function createSingleValueCache<T = any>(config: { ttl?: number } = {}): SingleValueCache<T> {
-  return new SingleValueCache<T>(config)
-}