openpets 1.0.5 → 1.0.6

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)
-}

package/logger.ts

@@ -1,143 +0,0 @@
-export enum LogLevel {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-  NONE = 4
-}
-
-const LOG_LEVEL_NAMES: Record<LogLevel, string> = {
-  [LogLevel.DEBUG]: 'DEBUG',
-  [LogLevel.INFO]: 'INFO',
-  [LogLevel.WARN]: 'WARN',
-  [LogLevel.ERROR]: 'ERROR',
-  [LogLevel.NONE]: 'NONE'
-}
-
-interface LoggerOptions {
-  namespace: string
-  level?: LogLevel
-  enabled?: boolean
-}
-
-export class Logger {
-  private namespace: string
-  private level: LogLevel
-  private enabled: boolean
-
-  constructor(options: LoggerOptions) {
-    this.namespace = options.namespace
-    this.enabled = options.enabled ?? this.detectLoggingEnabled()
-    this.level = options.level ?? this.detectLogLevel()
-  }
-
-  private detectLoggingEnabled(): boolean {
-    return process.env.ENABLE_LOGGING === 'true' ||
-           process.env.DEBUG === 'true' ||
-           process.argv.includes('--print-logs')
-  }
-
-  private detectLogLevel(): LogLevel {
-    const envLevel = process.env.LOG_LEVEL?.toUpperCase()
-    const argLevel = this.getArgLogLevel()
-
-    const levelStr = argLevel || envLevel || 'INFO'
-
-    switch (levelStr) {
-      case 'DEBUG':
-        return LogLevel.DEBUG
-      case 'INFO':
-        return LogLevel.INFO
-      case 'WARN':
-        return LogLevel.WARN
-      case 'ERROR':
-        return LogLevel.ERROR
-      case 'NONE':
-        return LogLevel.NONE
-      default:
-        return LogLevel.INFO
-    }
-  }
-
-  private getArgLogLevel(): string | undefined {
-    const logLevelIndex = process.argv.indexOf('--log-level')
-    if (logLevelIndex !== -1 && process.argv[logLevelIndex + 1]) {
-      return process.argv[logLevelIndex + 1].toUpperCase()
-    }
-    return undefined
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return this.enabled && level >= this.level
-  }
-
-  private formatTimestamp(): string {
-    const now = new Date()
-    const year = now.getFullYear()
-    const month = String(now.getMonth() + 1).padStart(2, '0')
-    const day = String(now.getDate()).padStart(2, '0')
-    const hours = String(now.getHours()).padStart(2, '0')
-    const minutes = String(now.getMinutes()).padStart(2, '0')
-    const seconds = String(now.getSeconds()).padStart(2, '0')
-    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`
-  }
-
-  private formatMessage(level: LogLevel, message: string, ...args: any[]): string {
-    const timestamp = this.formatTimestamp()
-    const levelName = LOG_LEVEL_NAMES[level].padEnd(5, ' ')
-    const prefix = `${levelName} ${timestamp} service=${this.namespace}`
-
-    if (args.length === 0) {
-      return `${prefix} ${message}`
-    }
-
-    const formattedArgs = args.map(arg => {
-      if (typeof arg === 'object') {
-        return JSON.stringify(arg, null, 2)
-      }
-      return String(arg)
-    }).join(' ')
-
-    return `${prefix} ${message} ${formattedArgs}`
-  }
-
-  debug(message: string, ...args: any[]): void {
-    if (this.shouldLog(LogLevel.DEBUG)) {
-      console.log(this.formatMessage(LogLevel.DEBUG, message, ...args))
-    }
-  }
-
-  info(message: string, ...args: any[]): void {
-    if (this.shouldLog(LogLevel.INFO)) {
-      console.log(this.formatMessage(LogLevel.INFO, message, ...args))
-    }
-  }
-
-  warn(message: string, ...args: any[]): void {
-    if (this.shouldLog(LogLevel.WARN)) {
-      console.warn(this.formatMessage(LogLevel.WARN, message, ...args))
-    }
-  }
-
-  error(message: string, ...args: any[]): void {
-    if (this.shouldLog(LogLevel.ERROR)) {
-      console.error(this.formatMessage(LogLevel.ERROR, message, ...args))
-    }
-  }
-
-  child(subNamespace: string): Logger {
-    return new Logger({
-      namespace: `${this.namespace}:${subNamespace}`,
-      level: this.level,
-      enabled: this.enabled
-    })
-  }
-}
-
-export function createLogger(namespace: string, options?: Partial<LoggerOptions>): Logger {
-  return new Logger({
-    namespace,
-    level: options?.level,
-    enabled: options?.enabled
-  })
-}