openpets 1.0.5 → 1.0.7

package/plugin-factory.ts

@@ -1,300 +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}`)
-          }
-        }
-      }
-    }
-
-    logger.info(`Loaded ${Object.keys(envVars).length} environment variables from project config`)
-
-  } 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)
-}