openpets 1.0.10 → 1.0.12

package/dist/src/core/openapi-generator.js

@@ -0,0 +1,800 @@
+/**
+ * OpenAPI Tool Generator
+ *
+ * Generates OpenPets-compatible tool definitions from OpenAPI/Swagger specifications.
+ * This is the highest-level way to create tools for API-first products.
+ *
+ * Usage:
+ *   pets generate-openapi --url https://api.example.com/openapi.json
+ *   pets generate-openapi --file ./openapi.json
+ *   pets generate-openapi           # Uses openapiSpec.url from package.json
+ *
+ * This tool:
+ * 1. Fetches or reads an OpenAPI spec (v3.0 or v3.1)
+ * 2. Parses endpoints into tool definitions
+ * 3. Generates Zod schemas from JSON Schema
+ * 4. Creates an openapi-client.ts file with all tools
+ */
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve, basename } from "path";
+import { config as loadDotenv } from "dotenv";
+import { createLogger } from "./logger";
+const logger = createLogger("openapi-generator");
+// ============================================================================
+// Config Loading
+// ============================================================================
+function loadConfigFromPackageJson(dir) {
+    const packageJsonPath = resolve(dir, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        // Check for explicit openapiSpec config
+        if (packageJson.openapiSpec) {
+            const petName = packageJson.name?.replace(/^@openpets\//, "") || basename(dir);
+            return {
+                config: packageJson.openapiSpec,
+                petName,
+            };
+        }
+        // Check for openapi-config.json in the pet directory
+        const configPath = resolve(dir, "openapi-config.json");
+        if (existsSync(configPath)) {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            const petName = packageJson.name?.replace(/^@openpets\//, "") || basename(dir);
+            return {
+                config: config,
+                petName,
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        logger.error(`Error reading package.json: ${error.message}`);
+        return null;
+    }
+}
+// ============================================================================
+// OpenAPI Spec Fetching
+// ============================================================================
+async function fetchOpenAPISpec(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+function readOpenAPISpec(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+}
+// ============================================================================
+// Schema Resolution
+// ============================================================================
+function resolveRef(spec, ref) {
+    // Handle $ref like "#/components/schemas/UserLogin"
+    const path = ref.replace(/^#\//, "").split("/");
+    let current = spec;
+    for (const segment of path) {
+        current = current[segment];
+        if (!current) {
+            logger.warn(`Could not resolve ref: ${ref}`);
+            return { type: "object" };
+        }
+    }
+    return current;
+}
+function resolveSchema(spec, schema) {
+    if (!schema)
+        return { type: "object" };
+    if (schema.$ref) {
+        return resolveSchema(spec, resolveRef(spec, schema.$ref));
+    }
+    // Handle allOf by merging schemas
+    if (schema.allOf) {
+        const merged = { type: "object", properties: {}, required: [] };
+        for (const subSchema of schema.allOf) {
+            const resolved = resolveSchema(spec, subSchema);
+            if (resolved.properties) {
+                merged.properties = { ...merged.properties, ...resolved.properties };
+            }
+            if (resolved.required) {
+                merged.required = [...(merged.required || []), ...resolved.required];
+            }
+        }
+        return merged;
+    }
+    return schema;
+}
+// ============================================================================
+// Zod Schema Generation
+// ============================================================================
+function schemaToZod(spec, schema, depth = 0) {
+    if (!schema)
+        return "z.any()";
+    // Resolve refs
+    const resolved = resolveSchema(spec, schema);
+    const desc = resolved.description
+        ? `.describe(${JSON.stringify(resolved.description)})`
+        : "";
+    // Handle anyOf (nullable/union types)
+    if (resolved.anyOf && Array.isArray(resolved.anyOf)) {
+        const nonNullTypes = resolved.anyOf.filter(s => s.type !== "null");
+        if (nonNullTypes.length === 1) {
+            return schemaToZod(spec, { ...nonNullTypes[0], description: resolved.description }, depth);
+        }
+        // Multiple types - use any with description
+        return `z.any()${desc}`;
+    }
+    // Handle oneOf similarly
+    if (resolved.oneOf && Array.isArray(resolved.oneOf)) {
+        const types = resolved.oneOf.filter(s => s.type !== "null");
+        if (types.length === 1) {
+            return schemaToZod(spec, { ...types[0], description: resolved.description }, depth);
+        }
+        return `z.any()${desc}`;
+    }
+    switch (resolved.type) {
+        case "string":
+            if (resolved.enum && resolved.enum.length > 0) {
+                const enumVals = resolved.enum.slice(0, 10).map(v => JSON.stringify(v)).join(", ");
+                const more = resolved.enum.length > 10 ? ` /* +${resolved.enum.length - 10} more */` : "";
+                return `z.enum([${enumVals}${more}])${desc}`;
+            }
+            if (resolved.format === "email") {
+                return `z.string().email()${desc}`;
+            }
+            if (resolved.format === "date-time") {
+                return `z.string()${desc.replace('.describe("', '.describe("ISO 8601 datetime: ')}`;
+            }
+            return `z.string()${desc}`;
+        case "number":
+        case "integer":
+            return `z.number()${desc}`;
+        case "boolean":
+            return `z.boolean()${desc}`;
+        case "array":
+            if (depth > 1) {
+                // OpenCode limitation: nested arrays become JSON strings
+                const arrayDesc = resolved.description
+                    ? `.describe(${JSON.stringify("JSON array: " + resolved.description)})`
+                    : '.describe("JSON array")';
+                return `z.string()${arrayDesc}`;
+            }
+            if (resolved.items) {
+                const itemsResolved = resolveSchema(spec, resolved.items);
+                if (itemsResolved.type === "string") {
+                    return `z.array(z.string())${desc}`;
+                }
+                if (itemsResolved.type === "number" || itemsResolved.type === "integer") {
+                    return `z.array(z.number())${desc}`;
+                }
+                if (itemsResolved.enum) {
+                    const enumVals = itemsResolved.enum.slice(0, 10).map((v) => JSON.stringify(v)).join(", ");
+                    return `z.array(z.enum([${enumVals}]))${desc}`;
+                }
+            }
+            // Complex array items - use JSON string
+            const arrayDesc = resolved.description
+                ? `.describe(${JSON.stringify("JSON array: " + resolved.description)})`
+                : '.describe("JSON array")';
+            return `z.string()${arrayDesc}`;
+        case "object":
+            if (depth > 0) {
+                // Nested objects become JSON strings (OpenCode limitation)
+                const objDesc = generateObjectDescription(spec, resolved);
+                return `z.string().describe(${JSON.stringify("JSON object: " + objDesc)})`;
+            }
+            // Top-level objects can be expanded
+            if (resolved.properties && Object.keys(resolved.properties).length > 0) {
+                const props = Object.entries(resolved.properties).map(([name, propSchema]) => {
+                    const isRequired = resolved.required?.includes(name);
+                    let zodType = schemaToZod(spec, propSchema, depth + 1);
+                    if (!isRequired && !zodType.includes(".optional()")) {
+                        zodType += ".optional()";
+                    }
+                    return `    ${name}: ${zodType}`;
+                });
+                return `z.object({\n${props.join(",\n")}\n  })`;
+            }
+            return `z.any()${desc}`;
+        default:
+            return `z.any()${desc}`;
+    }
+}
+function generateObjectDescription(spec, schema) {
+    const parts = [];
+    if (schema.description) {
+        parts.push(schema.description);
+    }
+    else if (schema.title) {
+        parts.push(schema.title);
+    }
+    if (schema.properties) {
+        const required = schema.required || [];
+        const propDescs = [];
+        for (const [name, propSchema] of Object.entries(schema.properties)) {
+            const resolved = resolveSchema(spec, propSchema);
+            const isRequired = required.includes(name);
+            const reqMarker = isRequired ? " (required)" : "";
+            let typeDesc = resolved.type || "any";
+            if (resolved.enum) {
+                typeDesc = `enum: [${resolved.enum.slice(0, 3).join(", ")}${resolved.enum.length > 3 ? "..." : ""}]`;
+            }
+            let desc = `${name}${reqMarker}: ${typeDesc}`;
+            if (resolved.description) {
+                desc += ` - ${resolved.description.substring(0, 50)}${resolved.description.length > 50 ? "..." : ""}`;
+            }
+            propDescs.push(desc);
+        }
+        if (propDescs.length > 0) {
+            parts.push("Properties: " + propDescs.slice(0, 5).join("; "));
+            if (propDescs.length > 5) {
+                parts.push(`... and ${propDescs.length - 5} more`);
+            }
+        }
+    }
+    return parts.join(". ") || "JSON object";
+}
+// ============================================================================
+// Tool Generation
+// ============================================================================
+function operationToTool(spec, path, method, operation, pathParams, petName, readOnlyPatterns, coreEndpoints) {
+    // Generate tool name from operationId or path
+    let toolName;
+    if (operation.operationId) {
+        // Convert operationId to kebab-case with pet prefix
+        toolName = `${petName}-${operation.operationId
+            .replace(/([A-Z])/g, "-$1")
+            .replace(/_/g, "-")
+            .replace(/--+/g, "-")
+            .replace(/^-/, "")
+            .toLowerCase()}`;
+    }
+    else {
+        // Generate from method + path
+        const pathParts = path.replace(/\{[^}]+\}/g, "").split("/").filter(Boolean);
+        toolName = `${petName}-${method}-${pathParts.join("-")}`.toLowerCase();
+    }
+    // Description from summary/description
+    const description = operation.summary || operation.description || `${method.toUpperCase()} ${path}`;
+    // Combine path-level and operation-level parameters
+    const allParams = [...pathParams, ...(operation.parameters || [])];
+    // Convert parameters to our format
+    const parameters = allParams.map(param => {
+        const paramSchema = resolveSchema(spec, param.schema);
+        return {
+            name: param.name,
+            in: param.in,
+            required: param.required || param.in === "path",
+            schema: schemaToZod(spec, paramSchema),
+            description: param.description || paramSchema.description,
+        };
+    });
+    // Handle request body - expand properties into individual parameters
+    let hasRequestBody = false;
+    if (operation.requestBody?.content) {
+        const jsonContent = operation.requestBody.content["application/json"];
+        if (jsonContent?.schema) {
+            hasRequestBody = true;
+            const bodySchema = resolveSchema(spec, jsonContent.schema);
+            const bodyRequired = operation.requestBody.required ?? false;
+            // Expand body properties into individual parameters with "body" location
+            if (bodySchema.properties && Object.keys(bodySchema.properties).length > 0) {
+                const requiredProps = bodySchema.required || [];
+                for (const [propName, propSchema] of Object.entries(bodySchema.properties)) {
+                    const resolvedProp = resolveSchema(spec, propSchema);
+                    const isRequired = bodyRequired && requiredProps.includes(propName);
+                    parameters.push({
+                        name: propName,
+                        in: "body",
+                        required: isRequired,
+                        schema: schemaToZod(spec, resolvedProp, 0),
+                        description: resolvedProp.description || resolvedProp.title,
+                    });
+                }
+            }
+        }
+    }
+    // Determine if read-only
+    const isReadOnly = method === "get" || method === "head" || method === "options" ||
+        readOnlyPatterns.some(pattern => toolName.includes(pattern) || operation.operationId?.includes(pattern));
+    // Determine if this is a core tool (always loaded) or requires env var
+    const tags = operation.tags || [];
+    let isCore = true; // Default to core if no coreEndpoints config
+    let loadEnvVar;
+    if (coreEndpoints) {
+        // Check if this tool matches any core endpoint criteria
+        const matchesCoreTag = coreEndpoints.tags?.some(tag => tags.map(t => t.toLowerCase()).includes(tag.toLowerCase()));
+        const matchesCorePath = coreEndpoints.paths?.some(pattern => path.toLowerCase().startsWith(pattern.toLowerCase()));
+        const matchesCoreOperationId = coreEndpoints.operationIds?.some(opId => operation.operationId?.toLowerCase().includes(opId.toLowerCase()));
+        isCore = !!(matchesCoreTag || matchesCorePath || matchesCoreOperationId);
+        if (!isCore) {
+            // Generate env var name for loading this tool group
+            // e.g., AI_HARMONY_LOAD_ADMIN_TOOLS=true
+            const tagName = (tags[0] || 'OTHER').replace(/[^a-zA-Z0-9]/g, '_').toUpperCase();
+            loadEnvVar = `${petName.toUpperCase().replace(/-/g, '_')}_LOAD_${tagName}_TOOLS`;
+        }
+    }
+    return {
+        name: toolName,
+        method: method.toUpperCase(),
+        path,
+        description,
+        parameters,
+        hasRequestBody,
+        isReadOnly,
+        tags,
+        isCore,
+        loadEnvVar,
+    };
+}
+function parseOpenAPISpec(spec, petName, config) {
+    const tools = [];
+    const readOnlyPatterns = config.readOnlyPatterns || ["list", "get", "search", "check", "status", "health"];
+    for (const [path, pathItem] of Object.entries(spec.paths)) {
+        const pathParams = pathItem.parameters || [];
+        const methods = [
+            { method: "get", operation: pathItem.get },
+            { method: "post", operation: pathItem.post },
+            { method: "put", operation: pathItem.put },
+            { method: "patch", operation: pathItem.patch },
+            { method: "delete", operation: pathItem.delete },
+        ];
+        for (const { method, operation } of methods) {
+            if (!operation)
+                continue;
+            // Skip deprecated operations
+            if (operation.deprecated)
+                continue;
+            // Check include/exclude filters
+            if (config.include && config.include.length > 0) {
+                const matches = config.include.some(pattern => operation.operationId?.includes(pattern) || path.includes(pattern));
+                if (!matches)
+                    continue;
+            }
+            if (config.exclude && config.exclude.length > 0) {
+                const matches = config.exclude.some(pattern => operation.operationId?.includes(pattern) || path.includes(pattern));
+                if (matches)
+                    continue;
+            }
+            const tool = operationToTool(spec, path, method, operation, pathParams, petName, readOnlyPatterns, config.coreEndpoints);
+            tools.push(tool);
+        }
+    }
+    return tools;
+}
+// ============================================================================
+// File Generation
+// ============================================================================
+/**
+ * Check if a property name needs to be quoted in JavaScript
+ */
+function needsQuotes(name) {
+    // Property names with special characters need quotes
+    return /[^a-zA-Z0-9_$]/.test(name) || /^\d/.test(name);
+}
+/**
+ * Get safe property accessor for args object
+ */
+function getPropertyAccessor(name) {
+    return needsQuotes(name) ? `args["${name}"]` : `args.${name}`;
+}
+/**
+ * Get safe property name for object literals
+ */
+function getPropertyName(name) {
+    return needsQuotes(name) ? `"${name}"` : name;
+}
+function generateToolDefinition(tool) {
+    // Build schema fields
+    const schemaFields = [];
+    // Add parameters (path, query, header, body)
+    for (const param of tool.parameters) {
+        let zodType = param.schema;
+        // Add description if not already present
+        if (param.description && !zodType.includes(".describe(")) {
+            // Insert .describe() before .optional() if present, otherwise append
+            if (zodType.includes(".optional()")) {
+                zodType = zodType.replace(".optional()", `.describe(${JSON.stringify(param.description)}).optional()`);
+            }
+            else {
+                zodType = zodType + `.describe(${JSON.stringify(param.description)})`;
+            }
+        }
+        // Add optional if not required and not already optional
+        if (!param.required && !zodType.includes(".optional()")) {
+            zodType += ".optional()";
+        }
+        // Use quoted property name if needed
+        const propName = getPropertyName(param.name);
+        schemaFields.push(`      ${propName}: ${zodType}`);
+    }
+    const schemaBody = schemaFields.length > 0
+        ? `z.object({\n${schemaFields.join(",\n")}\n    })`
+        : "z.object({})";
+    // Generate path with parameter substitution
+    const pathWithParams = tool.path.replace(/\{([^}]+)\}/g, (_, name) => `\${${getPropertyAccessor(name)}}`);
+    // Generate execute body
+    const pathParams = tool.parameters.filter(p => p.in === "path").map(p => p.name);
+    const queryParams = tool.parameters.filter(p => p.in === "query").map(p => p.name);
+    const headerParams = tool.parameters.filter(p => p.in === "header").map(p => p.name);
+    const bodyParams = tool.parameters.filter(p => p.in === "body").map(p => p.name);
+    let executeBody = `      const url = \`\${baseUrl}${pathWithParams}\``;
+    // Add query parameters
+    if (queryParams.length > 0) {
+        executeBody += `
+      const params = new URLSearchParams()
+${queryParams.map(p => `      if (${getPropertyAccessor(p)} !== undefined) params.append("${p}", String(${getPropertyAccessor(p)}))`).join("\n")}
+      const queryString = params.toString()
+      const fullUrl = queryString ? \`\${url}?\${queryString}\` : url`;
+    }
+    else {
+        executeBody += `
+      const fullUrl = url`;
+    }
+    // Build fetch options
+    executeBody += `
+      
+      const options: RequestInit = {
+        method: "${tool.method}",
+        headers: { ...headers }`;
+    // Add header parameters
+    if (headerParams.length > 0) {
+        for (const param of headerParams) {
+            executeBody += `,
+        ...(${getPropertyAccessor(param)} ? { "${param}": ${getPropertyAccessor(param)} } : {})`;
+        }
+    }
+    // Add body from body parameters
+    if (tool.hasRequestBody && bodyParams.length > 0) {
+        executeBody += `,
+        body: JSON.stringify({
+${bodyParams.map(p => `          ...(${getPropertyAccessor(p)} !== undefined ? { ${getPropertyName(p)}: ${getPropertyAccessor(p)} } : {})`).join(",\n")}
+        })`;
+    }
+    executeBody += `
+      }
+      
+      return fetchAPI(fullUrl, options)`;
+    return `  {
+    name: "${tool.name}",
+    description: ${JSON.stringify(tool.description)},
+    schema: ${schemaBody},
+    async execute(args: any) {
+${executeBody}
+    }
+  }`;
+}
+function generateOpenAPIClientFile(spec, tools, config, petName) {
+    // Separate core tools from loadEnv tools
+    const coreTools = tools.filter(t => t.isCore);
+    const loadEnvTools = tools.filter(t => !t.isCore);
+    // Group loadEnv tools by their env var
+    const loadEnvGroups = {};
+    for (const tool of loadEnvTools) {
+        const envVar = tool.loadEnvVar || 'OTHER';
+        if (!loadEnvGroups[envVar])
+            loadEnvGroups[envVar] = [];
+        loadEnvGroups[envVar].push(tool);
+    }
+    const coreToolDefinitions = coreTools.map(generateToolDefinition).join(",\n\n");
+    // Generate loadEnv tool groups
+    const loadEnvGroupDefinitions = [];
+    for (const [envVar, groupTools] of Object.entries(loadEnvGroups)) {
+        const groupDefs = groupTools.map(generateToolDefinition).join(",\n\n");
+        loadEnvGroupDefinitions.push(`
+// ${envVar} tools (${groupTools.length} tools)
+// Enable with: ${envVar}=true
+const ${envVar.toLowerCase().replace(/_/g, '')}Tools: ToolDefinition[] = process.env.${envVar} === 'true' ? [
+${groupDefs}
+] : []
+`);
+    }
+    // Determine base URL
+    // Priority: config.baseUrl > spec.servers[0].url > derived from spec URL
+    let baseUrl = config.baseUrl || spec.servers?.[0]?.url || "";
+    // If still empty and we have a URL, derive baseUrl from it
+    if (!baseUrl && config.url) {
+        try {
+            const specUrl = new URL(config.url);
+            baseUrl = `${specUrl.protocol}//${specUrl.host}`;
+        }
+        catch {
+            // Ignore URL parsing errors
+        }
+    }
+    // Determine auth setup
+    const authEnvVar = config.authEnvVar || `${petName.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+    const authType = config.authType || "bearer";
+    const apiKeyHeader = config.apiKeyHeader || "X-API-Key";
+    let authSetup;
+    switch (authType) {
+        case "apiKey":
+            authSetup = `if (apiKey) {
+  headers["${apiKeyHeader}"] = apiKey
+}`;
+            break;
+        case "basic":
+            authSetup = `if (apiKey) {
+  headers["Authorization"] = \`Basic \${apiKey}\`
+}`;
+            break;
+        case "none":
+            authSetup = "";
+            break;
+        default: // bearer
+            authSetup = `if (apiKey) {
+  headers["Authorization"] = \`Bearer \${apiKey}\`
+}`;
+    }
+    // Count read-only vs write tools
+    const readOnlyCount = tools.filter(t => t.isReadOnly).length;
+    const writeCount = tools.length - readOnlyCount;
+    const coreCount = coreTools.length;
+    const loadEnvCount = loadEnvTools.length;
+    // Group tools by tag for documentation
+    const tagGroups = {};
+    for (const tool of tools) {
+        const tag = tool.tags[0] || "Other";
+        if (!tagGroups[tag])
+            tagGroups[tag] = { tools: [], isCore: tool.isCore };
+        tagGroups[tag].tools.push(tool.name);
+    }
+    const tagDocs = Object.entries(tagGroups)
+        .map(([tag, info]) => ` *   ${tag}: ${info.tools.length} tools ${info.isCore ? '(CORE)' : '(loadEnv)'}`)
+        .join("\n");
+    // Generate env var documentation for loadEnv groups
+    const loadEnvDocs = Object.entries(loadEnvGroups)
+        .map(([envVar, groupTools]) => ` *   ${envVar}=true → ${groupTools.length} tools`)
+        .join("\n");
+    // Generate the combined tools array
+    const loadEnvVarNames = Object.keys(loadEnvGroups).map(ev => `...${ev.toLowerCase().replace(/_/g, '')}Tools`);
+    return `/**
+ * Auto-generated OpenAPI client tools
+ * 
+ * Source: ${config.url || config.file || "OpenAPI spec"}
+ * API: ${spec.info.title} v${spec.info.version}
+ * Generated: ${new Date().toISOString()}
+ * 
+ * Tools by category:
+${tagDocs}
+ * 
+ * Total: ${tools.length} tools (${readOnlyCount} read-only, ${writeCount} write)
+ * Core tools: ${coreCount} (always loaded)
+ * LoadEnv tools: ${loadEnvCount} (require env var to enable)
+ * 
+ * To enable additional tool groups, set environment variables:
+${loadEnvDocs}
+ * 
+ * DO NOT EDIT MANUALLY - Regenerate with: pets generate-openapi
+ */
+
+import { z, type ToolDefinition, createLogger, isReadOnly, filterToolsForReadOnly } from "openpets-sdk"
+
+const logger = createLogger("${petName}-client")
+
+// Configuration
+const baseUrl = "${baseUrl}"
+const apiKey = process.env.${authEnvVar}
+
+// Read-only mode check
+const readOnlyMode = isReadOnly("${petName}")
+
+if (readOnlyMode) {
+  logger.info("READ-ONLY MODE - write operations disabled")
+}
+
+// Common headers
+const headers: Record<string, string> = {
+  "Content-Type": "application/json",
+  "Accept": "application/json",
+}
+${authSetup}
+
+/**
+ * Fetch wrapper with error handling
+ */
+async function fetchAPI(url: string, options: RequestInit): Promise<string> {
+  try {
+    const response = await fetch(url, options)
+    
+    if (!response.ok) {
+      const errorText = await response.text()
+      return JSON.stringify({
+        success: false,
+        error: \`HTTP \${response.status}: \${errorText}\`,
+        status: response.status
+      }, null, 2)
+    }
+    
+    const contentType = response.headers.get("content-type")
+    if (contentType?.includes("application/json")) {
+      const data = await response.json()
+      return JSON.stringify(data, null, 2)
+    }
+    
+    const text = await response.text()
+    return JSON.stringify({ success: true, data: text }, null, 2)
+  } catch (error: any) {
+    return JSON.stringify({
+      success: false,
+      error: error.message
+    }, null, 2)
+  }
+}
+
+// Tools marked as write operations (filtered in read-only mode)
+// Based on HTTP method: POST, PUT, PATCH, DELETE are write operations
+const writeToolNames = new Set([
+${tools.filter(t => !t.isReadOnly).map(t => `  "${t.name}"`).join(",\n")}
+])
+
+// ============================================================================
+// CORE TOOLS - Always loaded (${coreCount} tools)
+// ============================================================================
+const coreTools: ToolDefinition[] = [
+${coreToolDefinitions}
+]
+
+// ============================================================================
+// LOADENV TOOLS - Require environment variable to enable
+// ============================================================================
+${loadEnvGroupDefinitions.join("\n")}
+
+/**
+ * All tools combined (core + enabled loadEnv groups)
+ */
+const allTools: ToolDefinition[] = [
+  ...coreTools,
+  ${loadEnvVarNames.join(",\n  ")}
+]
+
+// Log which tool groups are enabled
+const enabledGroups: string[] = ['core']
+${Object.keys(loadEnvGroups).map(ev => `if (process.env.${ev} === 'true') enabledGroups.push('${ev}')`).join("\n")}
+logger.info(\`Loaded tool groups: \${enabledGroups.join(', ')} (\${allTools.length} tools total)\`)
+
+/**
+ * Filter tools by read-only mode using HTTP method classification
+ */
+function filterByReadOnlyMode(tools: ToolDefinition[]): ToolDefinition[] {
+  if (!readOnlyMode) return tools
+  
+  const filtered = tools.filter(t => !writeToolNames.has(t.name))
+  const excluded = tools.length - filtered.length
+  
+  if (excluded > 0) {
+    logger.info(\`Filtered \${excluded} write tools in read-only mode\`)
+  }
+  
+  return filtered
+}
+
+export const openAPITools = filterByReadOnlyMode(allTools)
+
+export default openAPITools
+`;
+}
+// ============================================================================
+// Main Generator Function
+// ============================================================================
+export async function generateOpenAPITools(options = {}) {
+    const cwd = process.cwd();
+    const outputFile = options.outputFile || "openapi-client.ts";
+    // Load .env files
+    loadDotenv({ path: resolve(cwd, ".env") });
+    loadDotenv({ path: resolve(cwd, "../.env") });
+    loadDotenv({ path: resolve(cwd, "../../.env") });
+    // Determine config source
+    let config;
+    let petName;
+    // Check for URL or file from options first
+    if (options.url || options.file) {
+        const packageJsonPath = resolve(cwd, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            petName = packageJson.name?.replace(/^@openpets\//, "") || basename(cwd);
+        }
+        else {
+            petName = basename(cwd);
+        }
+        config = {
+            url: options.url,
+            file: options.file,
+            baseUrl: options.baseUrl,
+        };
+    }
+    else {
+        // Load from package.json
+        const loaded = loadConfigFromPackageJson(cwd);
+        if (!loaded) {
+            return {
+                success: false,
+                message: "No OpenAPI configuration found. Use --url or --file options, or add openapiSpec to package.json"
+            };
+        }
+        config = loaded.config;
+        petName = loaded.petName;
+    }
+    if (!config.url && !config.file) {
+        return {
+            success: false,
+            message: "No OpenAPI spec URL or file specified. Use --url or --file options."
+        };
+    }
+    if (options.verbose) {
+        console.log(`Pet Name: ${petName}`);
+        console.log(`Source: ${config.url || config.file}`);
+    }
+    try {
+        // Fetch or read the OpenAPI spec
+        let spec;
+        if (config.url) {
+            if (options.verbose) {
+                console.log(`Fetching OpenAPI spec from: ${config.url}`);
+            }
+            spec = await fetchOpenAPISpec(config.url);
+        }
+        else {
+            const filePath = resolve(cwd, config.file);
+            if (options.verbose) {
+                console.log(`Reading OpenAPI spec from: ${filePath}`);
+            }
+            spec = readOpenAPISpec(filePath);
+        }
+        if (options.verbose) {
+            console.log(`API: ${spec.info.title} v${spec.info.version}`);
+            console.log(`Paths: ${Object.keys(spec.paths).length}`);
+        }
+        // Dump spec for debugging
+        if (options.dumpSpec) {
+            const specFile = resolve(cwd, "openapi-spec-dump.json");
+            writeFileSync(specFile, JSON.stringify(spec, null, 2));
+            console.log(`Dumped spec to: ${specFile}`);
+        }
+        // Parse spec into tools
+        const tools = parseOpenAPISpec(spec, petName, config);
+        if (options.verbose) {
+            console.log(`Generated ${tools.length} tools`);
+            console.log("\nTools:");
+            for (const tool of tools) {
+                const marker = tool.isReadOnly ? "read" : "write";
+                console.log(`  [${marker}] ${tool.name} - ${tool.method} ${tool.path}`);
+            }
+        }
+        // Generate client file
+        const content = generateOpenAPIClientFile(spec, tools, config, petName);
+        if (options.dryRun) {
+            console.log("\n--- Generated openapi-client.ts ---");
+            console.log(content.slice(0, 5000));
+            if (content.length > 5000) {
+                console.log(`\n... (${content.length - 5000} more characters)`);
+            }
+            console.log("--- End ---\n");
+        }
+        else {
+            const outputPath = resolve(cwd, outputFile);
+            writeFileSync(outputPath, content);
+        }
+        const readOnlyCount = tools.filter(t => t.isReadOnly).length;
+        const writeCount = tools.length - readOnlyCount;
+        return {
+            success: true,
+            message: options.dryRun
+                ? `Would generate ${tools.length} tools (${readOnlyCount} read-only, ${writeCount} write) to ${outputFile}`
+                : `Generated ${tools.length} tools (${readOnlyCount} read-only, ${writeCount} write) to ${outputFile}`,
+            toolCount: tools.length,
+            outputPath: resolve(cwd, outputFile),
+            tools,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to generate OpenAPI tools: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=openapi-generator.js.map