openpets 1.0.5 → 1.0.6

package/mcp-factory.ts

@@ -1,180 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  Tool,
-} from "@modelcontextprotocol/sdk/types.js";
-import type { ToolDefinition, ToolRecord } from "./plugin-factory";
-import { createLogger } from "./logger";
-
-const logger = createLogger("mcp-factory");
-
-export interface MCPServerConfig {
-  name: string;
-  version: string;
-  description?: string;
-}
-
-export function extractToolsFromPlugin(pluginModule: any): ToolDefinition[] {
-  const tools: ToolDefinition[] = [];
-
-  if (pluginModule.tool && typeof pluginModule.tool === "object") {
-    const toolRecord = pluginModule.tool as ToolRecord;
-
-    for (const [name, toolDef] of Object.entries(toolRecord)) {
-      tools.push({
-        name: name,
-        description: toolDef.description,
-        schema: toolDef.args,
-        execute: toolDef.execute,
-      });
-    }
-  }
-
-  return tools;
-}
-
-function convertToolToMCPSchema(tool: ToolDefinition): Tool {
-  const schema = tool.schema as any;
-  const shape = schema.shape || schema._def?.shape?.();
-
-  const properties: Record<string, any> = {};
-  const required: string[] = [];
-
-  if (shape) {
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldSchema = value as any;
-      const fieldType = fieldSchema._def?.typeName;
-
-      if (fieldType === "ZodString") {
-        properties[key] = {
-          type: "string",
-          description: fieldSchema._def?.description || "",
-        };
-      } else if (fieldType === "ZodNumber") {
-        properties[key] = {
-          type: "number",
-          description: fieldSchema._def?.description || "",
-        };
-      } else if (fieldType === "ZodBoolean") {
-        properties[key] = {
-          type: "boolean",
-          description: fieldSchema._def?.description || "",
-        };
-      } else if (fieldType === "ZodArray") {
-        const elementType = fieldSchema._def?.type?._def?.typeName;
-        properties[key] = {
-          type: "array",
-          items: {
-            type: elementType === "ZodString" ? "string" : elementType === "ZodNumber" ? "number" : "string",
-          },
-          description: fieldSchema._def?.description || "",
-        };
-      } else {
-        properties[key] = {
-          type: "string",
-          description: fieldSchema._def?.description || "",
-        };
-      }
-
-      if (!fieldSchema._def?.checks?.some((check: any) => check.kind === "optional")) {
-        if (fieldSchema._def?.typeName !== "ZodOptional") {
-          required.push(key);
-        }
-      }
-    }
-  }
-
-  return {
-    name: tool.name.replace(/-/g, "_"),
-    description: tool.description,
-    inputSchema: {
-      type: "object",
-      properties,
-      ...(required.length > 0 ? { required } : {}),
-    },
-  };
-}
-
-export function createMCPServer(
-  config: MCPServerConfig,
-  tools: ToolDefinition[]
-): Server {
-  const server = new Server(
-    {
-      name: config.name,
-      version: config.version,
-    },
-    {
-      capabilities: {
-        tools: {},
-      },
-    }
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map((tool) => convertToolToMCPSchema(tool)),
-  }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params as {
-      name: string;
-      arguments: any;
-    };
-
-    const tool = tools.find((t) => t.name.replace(/-/g, "_") === name);
-
-    if (!tool) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: Unknown tool: ${name}`,
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    try {
-      const result = await tool.execute(args);
-      return {
-        content: [
-          {
-            type: "text",
-            text: result,
-          },
-        ],
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error executing ${name}: ${error}`,
-          },
-        ],
-        isError: true,
-      };
-    }
-  });
-
-  return server;
-}
-
-export async function startMCPServer(server: Server): Promise<void> {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error(`MCP server running on stdio`);
-}
-
-export function createMCPServerFromTools(
-  config: MCPServerConfig,
-  tools: ToolDefinition[]
-): () => Promise<void> {
-  return async () => {
-    const server = createMCPServer(config, tools);
-    await startMCPServer(server);
-  };
-}

package/mcp-server.ts

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-
-import { createMCPServer, startMCPServer, extractToolsFromPlugin } from "./mcp-factory";
-import { createLogger } from "./logger";
-import { resolve } from "path";
-import { readFileSync } from "fs";
-
-const logger = createLogger("mcp-server");
-
-async function main() {
-  const petName = process.argv[2] || process.env.PET_NAME;
-
-  if (!petName) {
-    logger.error("Pet name is required. Usage: node mcp-server.js <pet-name>");
-    logger.error("Example: node mcp-server.js polar");
-    logger.error("Or set PET_NAME environment variable");
-    process.exit(1);
-  }
-
-  logger.info("Starting MCP server for pet", { petName });
-
-  try {
-    const petPath = resolve(__dirname, `../../pets/${petName}`);
-    const packageJsonPath = resolve(petPath, "package.json");
-
-    let packageJson: any;
-    try {
-      packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    } catch (error) {
-      logger.error("Failed to read package.json", { petPath: packageJsonPath, error: String(error) });
-      process.exit(1);
-    }
-
-    const pluginModule = await import(`../../pets/${petName}/index.js`);
-
-    let plugin;
-    if (typeof pluginModule.default === "function") {
-      plugin = await pluginModule.default();
-    } else {
-      plugin = pluginModule.default;
-    }
-
-    const tools = extractToolsFromPlugin(plugin);
-
-    if (tools.length === 0) {
-      logger.error("No tools found in plugin", { petName });
-      process.exit(1);
-    }
-
-    logger.info("Extracted tools from plugin", { petName, toolCount: tools.length });
-
-    const server = createMCPServer(
-      {
-        name: packageJson.name || `openpets/${petName}`,
-        version: packageJson.version || "1.0.0",
-        description: packageJson.description || `${petName} MCP server`,
-      },
-      tools
-    );
-
-    await startMCPServer(server);
-  } catch (error) {
-    logger.error("Fatal error starting MCP server", { petName, error: String(error) });
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-main();

package/migrate-plugin.ts

@@ -1,220 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs'
-import { join } from 'path'
-
-export interface MigrationResult {
-  success: boolean
-  changes: string[]
-  errors: string[]
-}
-
-export class PluginMigrator {
-  migratePlugin(pluginPath: string): MigrationResult {
-    const indexPath = join(pluginPath, 'index.ts')
-    const changes: string[] = []
-    const errors: string[] = []
-
-    if (!existsSync(indexPath)) {
-      return {
-        success: false,
-        changes,
-        errors: ['index.ts not found']
-      }
-    }
-
-    try {
-      let code = readFileSync(indexPath, 'utf-8')
-      const original = code
-
-      code = this.addImports(code, changes)
-      code = this.convertInputSchemaToToolBuilder(code, changes)
-
-      if (code !== original) {
-        writeFileSync(indexPath, code, 'utf-8')
-        return { success: true, changes, errors }
-      } else {
-        return { success: true, changes: ['No changes needed'], errors }
-      }
-    } catch (error) {
-      errors.push(`Migration failed: ${error instanceof Error ? error.message : String(error)}`)
-      return { success: false, changes, errors }
-    }
-  }
-
-  private addImports(code: string, changes: string[]): string {
-    const hasToolImport = /import\s+{\s*tool\s*}\s+from\s+['"]@opencode-ai\/plugin['"]/.test(code)
-    const hasZodImport = /import.*from\s+['"]zod['"]/.test(code)
-    const hasPluginImport = /import.*from\s+['"]@opencode-ai\/plugin['"]/.test(code)
-
-    if (!hasPluginImport) {
-      code = `import type { Plugin } from "@opencode-ai/plugin"\n${code}`
-      changes.push('Added Plugin type import')
-    }
-
-    if (!hasToolImport) {
-      if (hasPluginImport) {
-        code = code.replace(
-          /import\s+(type\s+)?\{([^}]+)\}\s+from\s+['"]@opencode-ai\/plugin['"]/,
-          (match, typeKeyword, imports) => {
-            if (typeKeyword) {
-              return match.replace('}', ', tool }').replace('type ', '')
-            }
-            const cleanImports = imports.split(',').map((s: string) => s.trim()).filter(Boolean)
-            if (!cleanImports.includes('tool')) {
-              cleanImports.push('tool')
-            }
-            return `import { ${cleanImports.join(', ')} } from "@opencode-ai/plugin"`
-          }
-        )
-      } else {
-        code = `import { tool } from "@opencode-ai/plugin"\n${code}`
-      }
-      changes.push('Added tool import from @opencode-ai/plugin')
-    }
-
-    if (!hasZodImport) {
-      const pluginImportIndex = code.indexOf('import')
-      const firstNewline = code.indexOf('\n', pluginImportIndex)
-      code = code.slice(0, firstNewline + 1) + `import { z } from "zod"\n` + code.slice(firstNewline + 1)
-      changes.push('Added Zod import')
-    }
-
-    return code
-  }
-
-  private convertInputSchemaToToolBuilder(code: string, changes: string[]): string {
-    const toolPattern = /"([^"]+)":\s*{\s*description:\s*"([^"]+)",\s*inputSchema:\s*(\{[\s\S]*?\}),\s*async\s+execute\s*\(([^)]*)\)\s*(\{[\s\S]*?\n\s*\})\s*\}/g
-
-    let matchCount = 0
-    code = code.replace(toolPattern, (match, toolName, description, inputSchemaStr, argsParam, executeBody) => {
-      matchCount++
-
-      try {
-        const inputSchema = this.parseInputSchema(inputSchemaStr)
-        const zodArgs = this.convertToZodSchema(inputSchema)
-
-        const converted = `"${toolName}": tool({
-        description: "${description}",
-        args: ${zodArgs},
-        async execute(${argsParam}) ${executeBody}
-      })`
-
-        return converted
-      } catch (error) {
-        console.warn(`Failed to convert tool "${toolName}": ${error}`)
-        return match
-      }
-    })
-
-    if (matchCount > 0) {
-      changes.push(`Converted ${matchCount} tool(s) from inputSchema to tool() builder`)
-    }
-
-    return code
-  }
-
-  private parseInputSchema(schemaStr: string): any {
-    const cleaned = schemaStr
-      .replace(/\/\/.*$/gm, '')
-      .replace(/\/\*[\s\S]*?\*\//g, '')
-      .trim()
-
-    try {
-      const jsonStr = cleaned
-        .replace(/(\w+):/g, '"$1":')
-        .replace(/'/g, '"')
-
-      return JSON.parse(jsonStr)
-    } catch (error) {
-      return eval(`(${cleaned})`)
-    }
-  }
-
-  private convertToZodSchema(inputSchema: any): string {
-    if (!inputSchema.properties) {
-      return '{}'
-    }
-
-    const required = new Set(inputSchema.required || [])
-    const properties = inputSchema.properties
-
-    const zodFields: string[] = []
-
-    for (const [key, propDef] of Object.entries<any>(properties)) {
-      const isRequired = required.has(key)
-      let zodType = this.getZodType(propDef, isRequired)
-
-      const description = propDef.description
-      if (description) {
-        zodType += `.describe("${description.replace(/"/g, '\\"')}")`
-      }
-
-      zodFields.push(`${key}: ${zodType}`)
-    }
-
-    return `{\n          ${zodFields.join(',\n          ')}\n        }`
-  }
-
-  private getZodType(propDef: any, isRequired: boolean): string {
-    let zodType: string
-
-    switch (propDef.type) {
-      case 'string':
-        if (propDef.enum && Array.isArray(propDef.enum)) {
-          zodType = `z.enum([${propDef.enum.map((v: string) => `"${v}"`).join(', ')}])`
-        } else {
-          zodType = 'z.string()'
-        }
-        break
-
-      case 'number':
-        zodType = 'z.number()'
-        break
-
-      case 'boolean':
-        zodType = 'z.boolean()'
-        break
-
-      case 'array':
-        if (propDef.items) {
-          const itemType = this.getZodType(propDef.items, true)
-          zodType = `z.array(${itemType})`
-        } else {
-          zodType = 'z.array(z.any())'
-        }
-        break
-
-      case 'object':
-        if (propDef.additionalProperties) {
-          const valueType = this.getZodType(propDef.additionalProperties, true)
-          zodType = `z.record(${valueType})`
-        } else {
-          zodType = 'z.object({})'
-        }
-        break
-
-      default:
-        zodType = 'z.any()'
-    }
-
-    if (!isRequired) {
-      zodType += '.optional()'
-    }
-
-    return zodType
-  }
-
-  printMigrationResult(pluginName: string, result: MigrationResult): void {
-    const status = result.success ? '✅' : '❌'
-    console.log(`\n${status} ${pluginName}`)
-
-    if (result.changes.length > 0) {
-      console.log('  Changes:')
-      result.changes.forEach(change => console.log(`    • ${change}`))
-    }
-
-    if (result.errors.length > 0) {
-      console.log('  Errors:')
-      result.errors.forEach(error => console.log(`    ❌ ${error}`))
-    }
-  }
-}

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