openpets 1.0.4 → 1.0.6

package/pets-registry.ts

@@ -1,160 +0,0 @@
-import { readdirSync, existsSync, readFileSync } from "fs"
-import { join, resolve } from "path"
-import { createLogger } from "./logger"
-
-const logger = createLogger("pets-registry")
-
-export interface PetMetadata {
-  id: string
-  name: string
-  description: string
-  version: string
-  keywords: string[]
-  author?: string
-  repository?: {
-    type: string
-    url: string
-    directory?: string
-  }
-  queries?: string[]
-  scenarios?: Record<string, string[]>
-  envVariables?: {
-    required?: Array<{ name: string; description: string; provider?: string }>
-    optional?: Array<{ name: string; description: string; provider?: string }>
-  }
-  utils?: {
-    dependencies?: string[]
-    paths?: string[]
-  }
-}
-
-export class PetsRegistry {
-  private pets: Map<string, PetMetadata> = new Map()
-  private petsDir: string
-
-  constructor(petsDir?: string) {
-    this.petsDir = petsDir || resolve(__dirname, "../../pets")
-    this.loadPets()
-  }
-
-  private loadPets(): void {
-    try {
-      if (!existsSync(this.petsDir)) {
-        logger.warn(`Pets directory not found: ${this.petsDir}`)
-        return
-      }
-
-      const entries = readdirSync(this.petsDir, { withFileTypes: true })
-
-      for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') {
-          continue
-        }
-
-        const petDir = join(this.petsDir, entry.name)
-        const packageJsonPath = join(petDir, 'package.json')
-
-        if (!existsSync(packageJsonPath)) {
-          continue
-        }
-
-        try {
-          const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
-
-          const metadata: PetMetadata = {
-            id: entry.name,
-            name: packageJson.name || entry.name,
-            description: packageJson.description || '',
-            version: packageJson.version || '1.0.0',
-            keywords: packageJson.keywords || [],
-            author: packageJson.author,
-            repository: packageJson.repository,
-            queries: packageJson.queries,
-            scenarios: packageJson.scenarios,
-            envVariables: packageJson.envVariables,
-            utils: packageJson.utils
-          }
-
-          this.pets.set(entry.name, metadata)
-          logger.debug(`Loaded pet: ${entry.name}`)
-        } catch (error: any) {
-          logger.error(`Failed to load pet ${entry.name}: ${error.message}`)
-        }
-      }
-
-      logger.info(`Loaded ${this.pets.size} pets`)
-    } catch (error: any) {
-      logger.error(`Failed to load pets: ${error.message}`)
-    }
-  }
-
-  getAllPets(): PetMetadata[] {
-    return Array.from(this.pets.values())
-  }
-
-  getPet(id: string): PetMetadata | undefined {
-    return this.pets.get(id)
-  }
-
-  searchPets(query: string): PetMetadata[] {
-    if (!query || query.trim() === '') {
-      return this.getAllPets()
-    }
-
-    const normalizedQuery = query.toLowerCase().trim()
-    const results: PetMetadata[] = []
-
-    for (const pet of this.pets.values()) {
-      const searchableText = [
-        pet.id,
-        pet.name,
-        pet.description,
-        ...(pet.keywords || []),
-        pet.author || '',
-      ].join(' ').toLowerCase()
-
-      if (searchableText.includes(normalizedQuery)) {
-        results.push(pet)
-      }
-    }
-
-    return results
-  }
-
-  getPetsByCategory(keywords: string[]): PetMetadata[] {
-    return this.getAllPets().filter(pet =>
-      keywords.some(keyword =>
-        pet.keywords?.some(k => k.toLowerCase().includes(keyword.toLowerCase()))
-      )
-    )
-  }
-
-  reload(): void {
-    this.pets.clear()
-    this.loadPets()
-  }
-}
-
-let defaultRegistry: PetsRegistry | null = null
-
-export function getPetsRegistry(petsDir?: string): PetsRegistry {
-  if (!defaultRegistry) {
-    defaultRegistry = new PetsRegistry(petsDir)
-  }
-  return defaultRegistry
-}
-
-export function searchPetsInRegistry(query: string, petsDir?: string): PetMetadata[] {
-  const registry = getPetsRegistry(petsDir)
-  return registry.searchPets(query)
-}
-
-export function getAllPetsFromRegistry(petsDir?: string): PetMetadata[] {
-  const registry = getPetsRegistry(petsDir)
-  return registry.getAllPets()
-}
-
-export function getPetFromRegistry(id: string, petsDir?: string): PetMetadata | undefined {
-  const registry = getPetsRegistry(petsDir)
-  return registry.getPet(id)
-}

package/plugin-factory.ts

@@ -1,309 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { readFileSync, existsSync } from "fs"
-import { resolve, dirname } from "path"
-import { createLogger } from "./logger"
-import { config } from "dotenv"
-import type * as z from "zod"
-import * as zodRuntime from "zod"
-
-// ============================================================================
-// CRITICAL: SCHEMA FORMAT REQUIREMENTS
-// ============================================================================
-//
-// 1. ALWAYS use tool.schema for the Zod instance (not direct "zod" import)
-//    This ensures the same Zod version as OpenCode
-//
-// 2. SIMPLE TYPES ONLY - Do NOT use nested schemas
-//    ✅ ALLOWED:
-//       - z.string()
-//       - z.number()
-//       - z.boolean()
-//       - z.array(z.string())
-//       - z.array(z.number())
-//       - z.object({ field: z.string() })
-//
-//    ❌ NOT ALLOWED (will cause runtime errors):
-//       - z.array(z.object({...}))               // Nested object in array
-//       - z.object({ nested: z.object({...}) })  // Nested object in object
-//       - z.record(z.string())                   // Record with any nested type
-//       - z.union([z.object({...}), ...])        // Union with nested types
-//
-// 3. WORKAROUND for complex data structures:
-//    Use z.string() with JSON serialization
-//    Example:
-//      schema: z.object({
-//        dataJson: z.string().describe("JSON string of data array")
-//      }),
-//      execute(args) {
-//        const data = JSON.parse(args.dataJson)
-//        // ... process data
-//      }
-//
-// ============================================================================
-
-export { tool }
-export { zodRuntime as z }
-
-const logger = createLogger("plugin-factory")
-
-export interface ToolDefinition<T extends Record<string, any> = any> {
-  name: string
-  description: string
-  schema: z.ZodType<any, any, any>
-  execute: (args: T, context?: any) => Promise<string>
-}
-
-export interface ProviderSpec {
-  name: string
-  displayName: string
-  envVars: {
-    required: Array<{
-      name: string
-      description: string
-      example?: string
-    }>
-  }
-  capabilities: string[]
-  comingSoon?: string[]
-  credentialsUrl?: string
-  credentialsDocUrl?: string
-}
-
-export interface ProviderValidationResult {
-  provider: string
-  configured: boolean
-  missingVars: string[]
-  spec?: ProviderSpec
-}
-
-export interface ProviderValidationReport {
-  hasRequiredProvider: boolean
-  requiredResults: ProviderValidationResult[]
-  optionalResults: ProviderValidationResult[]
-  errors: string[]
-}
-
-export type ToolRecord = Record<string, {
-  description: string
-  args: z.ZodObject<any>
-  execute: (args: any, context?: any) => Promise<string>
-}>
-
-export function createPlugin(tools: ToolDefinition[]): { tool: ToolRecord } {
-  const toolRecord: ToolRecord = {}
-
-  for (const toolDef of tools) {
-    const schema = toolDef.schema as any
-    toolRecord[toolDef.name] = tool({
-      description: toolDef.description,
-      args: schema.shape || schema,
-      execute: toolDef.execute
-    })
-  }
-
-  return { tool: toolRecord }
-}
-
-export function createSingleTool<T extends Record<string, any>>(
-  definition: Omit<ToolDefinition<T>, 'name'>
-): {
-  description: string
-  args: z.ZodObject<any>
-  execute: (args: T, context?: any) => Promise<string>
-} {
-  const schema = definition.schema as any
-  return tool({
-    description: definition.description,
-    args: schema.shape || schema,
-    execute: definition.execute
-  })
-}
-
-function loadProviderSpec(providerPath: string, pluginDir: string): ProviderSpec | null {
-  try {
-    let packagePath: string
-
-    if (providerPath.startsWith('openpets/')) {
-      const petName = providerPath.replace('openpets/', '')
-      packagePath = resolve(pluginDir, `../${petName}/package.json`)
-    } else if (providerPath.startsWith('@/utils/')) {
-      const normalizedPath = providerPath.replace('@/utils/', '')
-      packagePath = resolve(pluginDir, `../../src/utils/${normalizedPath}/package.json`)
-    } else {
-      logger.debug(`Unknown provider path format: ${providerPath}`)
-      return null
-    }
-
-    const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'))
-
-    if (packageJson.provider) {
-      return packageJson.provider
-    }
-
-    if (packageJson.envVariables?.required) {
-      return {
-        name: packageJson.name || providerPath,
-        displayName: packageJson.description?.split('-')[0]?.trim() || providerPath,
-        envVars: {
-          required: packageJson.envVariables.required.map((env: any) => ({
-            name: env.name,
-            description: env.description,
-            example: env.example
-          }))
-        },
-        capabilities: packageJson.keywords?.filter((k: string) => k !== 'opencode' && k !== 'plugin') || []
-      }
-    }
-
-    return null
-  } catch (error: any) {
-    logger.debug(`Could not load provider spec for ${providerPath}: ${error.message}`)
-    return null
-  }
-}
-
-function validateProvider(providerPath: string, pluginDir: string): ProviderValidationResult {
-  const spec = loadProviderSpec(providerPath, pluginDir)
-
-  if (!spec) {
-    return {
-      provider: providerPath,
-      configured: false,
-      missingVars: [],
-      spec: undefined
-    }
-  }
-
-  const missingVars: string[] = []
-
-  for (const envVar of spec.envVars.required) {
-    if (!process.env[envVar.name]) {
-      missingVars.push(envVar.name)
-    }
-  }
-
-  return {
-    provider: providerPath,
-    configured: missingVars.length === 0,
-    missingVars,
-    spec
-  }
-}
-
-export function validateProviders(packageJson: any, pluginDir: string): ProviderValidationReport {
-  const errors: string[] = []
-  const requiredResults: ProviderValidationResult[] = []
-  const optionalResults: ProviderValidationResult[] = []
-
-  if (!packageJson.providers) {
-    return { hasRequiredProvider: true, requiredResults, optionalResults, errors }
-  }
-
-  const anyProviders = packageJson.providers.any || []
-  const requiredProviders = packageJson.providers.required || []
-  const optionalProviders = packageJson.providers.optional || []
-
-  const allProviders = [...anyProviders, ...requiredProviders]
-
-  for (const providerPath of allProviders) {
-    const result = validateProvider(providerPath, pluginDir)
-    requiredResults.push(result)
-  }
-
-  for (const providerPath of optionalProviders) {
-    const result = validateProvider(providerPath, pluginDir)
-    optionalResults.push(result)
-  }
-
-  const hasRequiredProvider = requiredResults.length === 0 || requiredResults.some(r => r.configured)
-
-  if (!hasRequiredProvider && requiredResults.length > 0) {
-    const providerNames = requiredResults
-      .map(r => r.spec?.displayName || r.provider)
-      .join(', ')
-
-    errors.push(`At least one provider must be configured. Available providers: ${providerNames}`)
-    errors.push(`\nConfigure any one of the following:\n`)
-
-    for (const result of requiredResults) {
-      if (result.spec) {
-        errors.push(`${result.spec.displayName}:`)
-        for (const envVar of result.spec.envVars.required) {
-          errors.push(`  - ${envVar.name}: ${envVar.description}`)
-          if (envVar.example) {
-            errors.push(`    Example: ${envVar.example}`)
-          }
-        }
-        errors.push('')
-      }
-    }
-  }
-
-  return { hasRequiredProvider, requiredResults, optionalResults, errors }
-}
-
-export interface EnvConfig {
-  [key: string]: string
-}
-
-export function loadEnv(petId?: string): EnvConfig {
-  const envVars: EnvConfig = {}
-
-  try {
-    const projectRoot = resolve(process.cwd())
-    const dotenvPath = resolve(projectRoot, '.env')
-    const petsConfigPath = resolve(projectRoot, '.pets', 'config.json')
-
-    logger.debug(`Loading env vars for pet: ${petId || 'global'}`)
-
-    if (petId && existsSync(petsConfigPath)) {
-      try {
-        const petsConfig = JSON.parse(readFileSync(petsConfigPath, 'utf-8'))
-        const petEnvConfig = petsConfig.envConfig?.[petId] || {}
-
-        for (const [key, value] of Object.entries(petEnvConfig)) {
-          if (typeof value === 'string' && value.length > 0) {
-            envVars[key] = value
-            logger.debug(`Loaded from .pets/config.json: ${key}`)
-          }
-        }
-      } catch (error: any) {
-        logger.debug(`Failed to load pet config: ${error.message}`)
-      }
-    }
-
-    if (existsSync(dotenvPath)) {
-      const dotenvResult = config({ path: dotenvPath })
-
-      if (dotenvResult.parsed) {
-        for (const [key, value] of Object.entries(dotenvResult.parsed)) {
-          if (value && value.length > 0) {
-            envVars[key] = value
-            logger.debug(`Loaded from .env (overriding if exists): ${key}`)
-          }
-        }
-      }
-    }
-
-    for (const [key, value] of Object.entries(process.env)) {
-      if (value && value.length > 0) {
-        if (!envVars[key]) {
-          envVars[key] = value
-          logger.debug(`Loaded from process.env: ${key}`)
-        }
-      }
-    }
-
-    logger.info(`Loaded ${Object.keys(envVars).length} environment variables`)
-
-  } catch (error: any) {
-    logger.error(`Error loading environment variables: ${error.message}`)
-  }
-
-  return envVars
-}
-
-export function getEnv(key: string, petId?: string): string | undefined {
-  const envVars = loadEnv(petId)
-  return envVars[key]
-}

package/prompt-utils.ts

@@ -1,130 +0,0 @@
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'fs'
-import { join, dirname } from 'path'
-
-interface PetPrompt {
-  name: string
-  content: string
-  description: string
-}
-
-export function extractPetPrompts(agentsMdPath: string, enabledPets: string[]): PetPrompt[] {
-  if (!existsSync(agentsMdPath)) {
-    console.warn(`AGENTS.md not found at ${agentsMdPath}`)
-    return []
-  }
-
-  const agentsContent = readFileSync(agentsMdPath, 'utf-8')
-  const prompts: PetPrompt[] = []
-
-  for (const pet of enabledPets) {
-    const petName = pet.replace('openpets/', '')
-    const prompt = extractPromptForPet(agentsContent, petName)
-    if (prompt) {
-      prompts.push(prompt)
-    }
-  }
-
-  return prompts
-}
-
-function extractPromptForPet(content: string, petName: string): PetPrompt | null {
-  // Simple regex to find plugin section  
-  const pattern = '### [^\\n]*`pets/' + petName + '`'
-  const pluginRegex = new RegExp(pattern, 'i')
-  const match = content.match(pluginRegex)
-  
-  if (!match) {
-    console.warn(`No section found for pet: ${petName}`)
-    return null
-  }
-
-  const startIndex = match.index!
-  const afterHeader = content.substring(startIndex + match[0].length)
-  
-  // Find next ### section or end of file
-  const nextSectionMatch = afterHeader.match(/### /)
-  const endIndex = nextSectionMatch ? startIndex + match[0].length + nextSectionMatch.index! : content.length
-  
-  const sectionContent = content.substring(startIndex, endIndex).trim()
-  
-  // Extract description (first paragraph)
-  const lines = sectionContent.split('\\n')
-  let description = ''
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim() && !lines[i].startsWith('**') && !lines[i].startsWith('*')) {
-      description = lines[i].trim()
-      break
-    }
-  }
-  
-  if (!description) {
-    description = `System prompt for ${petName} plugin`
-  }
-
-  // Build simple system prompt
-  const systemPrompt = `# ${petName.charAt(0).toUpperCase() + petName.slice(1)} Plugin
-
-${description}
-
-## Usage Guidance
-
-This plugin provides tools for interacting with ${petName} services.
-
-## Important Notes
-
-- Always check for required environment variables before using tools
-- Read tool descriptions carefully to understand parameters  
-- Handle errors gracefully and provide helpful feedback to users
-`
-
-  return {
-    name: petName,
-    content: systemPrompt,
-    description
-  }
-}
-
-export function writePetPrompts(prompts: PetPrompt[], outputDir: string): void {
-  if (!existsSync(outputDir)) {
-    mkdirSync(outputDir, { recursive: true })
-  }
-
-  for (const prompt of prompts) {
-    const promptPath = join(outputDir, `${prompt.name}.md`)
-    writeFileSync(promptPath, prompt.content, 'utf-8')
-    console.log(`Wrote prompt: ${promptPath}`)
-  }
-}
-
-export function readPetsConfig(configPath: string): { enabled: string[], disabled: string[] } {
-  if (!existsSync(configPath)) {
-    return { enabled: [], disabled: [] }
-  }
-
-  try {
-    const config = JSON.parse(readFileSync(configPath, 'utf-8'))
-    return {
-      enabled: config.enabled || [],
-      disabled: config.disabled || []
-    }
-  } catch (error) {
-    console.warn(`Error reading pets config: ${error}`)
-    return { enabled: [], disabled: [] }
-  }
-}
-
-export function writePetsConfig(configPath: string, enabled: string[], disabled: string[]): void {
-  const configDir = dirname(configPath)
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true })
-  }
-
-  const config = {
-    enabled,
-    disabled,
-    lastUpdated: new Date().toISOString()
-  }
-
-  writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8')
-  console.log(`Wrote pets config: ${configPath}`)
-}

package/schema-helpers.ts

@@ -1,59 +0,0 @@
-import { z } from "zod"
-
-export const commonSchemas = {
-  id: z.string().describe("Unique identifier"),
-  url: z.string().url().describe("URL"),
-  email: z.string().email().describe("Email address"),
-
-  pagination: {
-    perPage: z.number().optional().describe("Number of results per page (default: 20, max: 100)"),
-    page: z.number().optional().describe("Page number")
-  },
-
-  search: z.string().optional().describe("Search query"),
-
-  state: (values: string[]) => z.enum(values as [string, ...string[]]).optional().describe("Filter by state")
-}
-
-export function withPagination<T extends z.ZodRawShape>(shape: T) {
-  return z.object({
-    ...shape,
-    ...commonSchemas.pagination
-  })
-}
-
-export function optional<T extends z.ZodTypeAny>(schema: T) {
-  return schema.optional()
-}
-
-export function arrayOf<T extends z.ZodTypeAny>(schema: T) {
-  return z.array(schema)
-}
-
-export function stringEnum(...values: string[]) {
-  return z.enum(values as [string, ...string[]])
-}
-
-export function stringField(description: string) {
-  return z.string().describe(description)
-}
-
-export function optionalString(description: string) {
-  return z.string().optional().describe(description)
-}
-
-export function numberField(description: string) {
-  return z.number().describe(description)
-}
-
-export function optionalNumber(description: string) {
-  return z.number().optional().describe(description)
-}
-
-export function booleanField(description: string) {
-  return z.boolean().describe(description)
-}
-
-export function optionalBoolean(description: string) {
-  return z.boolean().optional().describe(description)
-}