openpets 1.0.4

package/deploy-pet.ts

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,280 @@
+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.d.ts

@@ -0,0 +1,32 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+interface LoggerOptions {
+    namespace: string;
+    level?: LogLevel;
+    enabled?: boolean;
+}
+export declare class Logger {
+    private namespace;
+    private level;
+    private enabled;
+    constructor(options: LoggerOptions);
+    private detectLoggingEnabled;
+    private detectLogLevel;
+    private getArgLogLevel;
+    private shouldLog;
+    private formatTimestamp;
+    private formatMessage;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    child(subNamespace: string): Logger;
+}
+export declare function createLogger(namespace: string, options?: Partial<LoggerOptions>): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/logger.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const LOG_LEVEL_NAMES = {
+    [LogLevel.DEBUG]: 'DEBUG',
+    [LogLevel.INFO]: 'INFO',
+    [LogLevel.WARN]: 'WARN',
+    [LogLevel.ERROR]: 'ERROR',
+    [LogLevel.NONE]: 'NONE'
+};
+class Logger {
+    constructor(options) {
+        this.namespace = options.namespace;
+        this.enabled = options.enabled ?? this.detectLoggingEnabled();
+        this.level = options.level ?? this.detectLogLevel();
+    }
+    detectLoggingEnabled() {
+        return process.env.ENABLE_LOGGING === 'true' ||
+            process.env.DEBUG === 'true' ||
+            process.argv.includes('--print-logs');
+    }
+    detectLogLevel() {
+        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;
+        }
+    }
+    getArgLogLevel() {
+        const logLevelIndex = process.argv.indexOf('--log-level');
+        if (logLevelIndex !== -1 && process.argv[logLevelIndex + 1]) {
+            return process.argv[logLevelIndex + 1].toUpperCase();
+        }
+        return undefined;
+    }
+    shouldLog(level) {
+        return this.enabled && level >= this.level;
+    }
+    formatTimestamp() {
+        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}`;
+    }
+    formatMessage(level, message, ...args) {
+        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, ...args) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            console.log(this.formatMessage(LogLevel.DEBUG, message, ...args));
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            console.log(this.formatMessage(LogLevel.INFO, message, ...args));
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            console.warn(this.formatMessage(LogLevel.WARN, message, ...args));
+        }
+    }
+    error(message, ...args) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            console.error(this.formatMessage(LogLevel.ERROR, message, ...args));
+        }
+    }
+    child(subNamespace) {
+        return new Logger({
+            namespace: `${this.namespace}:${subNamespace}`,
+            level: this.level,
+            enabled: this.enabled
+        });
+    }
+}
+exports.Logger = Logger;
+function createLogger(namespace, options) {
+    return new Logger({
+        namespace,
+        level: options?.level,
+        enabled: options?.enabled
+    });
+}

package/logger.ts

@@ -0,0 +1,143 @@
+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
+  })
+}