openpets 1.0.4 → 1.0.6

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

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