@pattern-stack/frontend-patterns 0.1.0 → 0.1.1

package/cli/index.js

@@ -1,3210 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// cli/index.ts
-var index_exports = {};
-__export(index_exports, {
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
-var import_commander = require("commander");
-
-// cli/commands/generate-hooks.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
-
-// src/codegen/openapi/parser.js
-var import_fs = require("fs");
-var import_path = require("path");
-var OpenAPIParser = class {
-  spec;
-  refs = /* @__PURE__ */ new Map();
-  constructor(spec) {
-    this.spec = spec;
-    this.buildRefsMap();
-  }
-  /**
-   * Parse the OpenAPI specification into our intermediate representation
-   */
-  parse() {
-    return {
-      info: this.parseInfo(),
-      servers: this.parseServers(),
-      endpoints: this.parseEndpoints(),
-      schemas: this.parseSchemas(),
-      security: this.parseSecurity()
-    };
-  }
-  parseInfo() {
-    return {
-      title: this.spec.info.title,
-      version: this.spec.info.version,
-      description: this.spec.info.description
-    };
-  }
-  parseServers() {
-    if (!this.spec.servers)
-      return [];
-    return this.spec.servers.map((server) => ({
-      url: server.url,
-      description: server.description,
-      variables: server.variables ? Object.fromEntries(Object.entries(server.variables).map(([key, variable]) => [
-        key,
-        variable.default || ""
-      ])) : void 0
-    }));
-  }
-  parseEndpoints() {
-    const endpoints = [];
-    for (const [path, pathItem] of Object.entries(this.spec.paths || {})) {
-      if (!pathItem)
-        continue;
-      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
-      for (const method of methods) {
-        const operation = pathItem[method];
-        if (!operation)
-          continue;
-        endpoints.push({
-          path,
-          method,
-          operationId: operation.operationId,
-          summary: operation.summary,
-          description: operation.description,
-          tags: operation.tags,
-          parameters: this.parseParameters(operation.parameters),
-          requestBody: operation.requestBody ? this.parseRequestBody(operation.requestBody) : void 0,
-          responses: this.parseResponses(operation.responses),
-          security: operation.security ? this.parseOperationSecurity(operation.security) : void 0
-        });
-      }
-    }
-    return endpoints;
-  }
-  parseParameters(parameters) {
-    if (!parameters)
-      return [];
-    return parameters.map((param) => {
-      const resolved = this.resolveRef(param);
-      return {
-        name: resolved.name,
-        in: resolved.in,
-        required: resolved.required || false,
-        schema: this.parseSchema(resolved.schema),
-        description: resolved.description
-      };
-    });
-  }
-  parseRequestBody(requestBody) {
-    const resolved = this.resolveRef(requestBody);
-    return {
-      required: resolved.required || false,
-      description: resolved.description,
-      content: Object.fromEntries(Object.entries(resolved.content || {}).map(([mediaType, mediaTypeObj]) => [
-        mediaType,
-        { schema: this.parseSchema(mediaTypeObj.schema) }
-      ]))
-    };
-  }
-  parseResponses(responses) {
-    return Object.entries(responses).map(([statusCode, response]) => {
-      const resolved = this.resolveRef(response);
-      return {
-        statusCode,
-        description: resolved.description,
-        content: resolved.content ? Object.fromEntries(Object.entries(resolved.content).map(([mediaType, mediaTypeObj]) => [
-          mediaType,
-          { schema: this.parseSchema(mediaTypeObj.schema) }
-        ])) : void 0,
-        headers: resolved.headers ? Object.fromEntries(Object.entries(resolved.headers).map(([headerName, header]) => [
-          headerName,
-          this.parseSchema(this.resolveRef(header).schema)
-        ])) : void 0
-      };
-    });
-  }
-  parseSchema(schema) {
-    if (!schema) {
-      return { type: "any" };
-    }
-    if ("$ref" in schema) {
-      return {
-        type: "any",
-        // Will be resolved later
-        ref: schema.$ref,
-        originalRef: schema.$ref
-      };
-    }
-    const resolved = schema;
-    if (resolved.type === "array") {
-      return {
-        type: "array",
-        items: this.parseSchema(resolved.items),
-        description: resolved.description,
-        nullable: resolved.nullable
-      };
-    }
-    if (resolved.type === "object" || resolved.properties) {
-      return {
-        type: "object",
-        properties: resolved.properties ? Object.fromEntries(Object.entries(resolved.properties).map(([propName, propSchema]) => [
-          propName,
-          this.parseSchema(propSchema)
-        ])) : void 0,
-        required: resolved.required,
-        description: resolved.description,
-        nullable: resolved.nullable
-      };
-    }
-    const type = this.mapOpenAPIType(resolved.type);
-    return {
-      type,
-      format: resolved.format,
-      enum: resolved.enum,
-      description: resolved.description,
-      example: resolved.example,
-      nullable: resolved.nullable
-    };
-  }
-  parseSchemas() {
-    if (!this.spec.components?.schemas)
-      return [];
-    return Object.entries(this.spec.components.schemas).map(([name, schema]) => ({
-      ...this.parseSchema(schema),
-      ref: `#/components/schemas/${name}`
-    }));
-  }
-  parseSecurity() {
-    if (!this.spec.components?.securitySchemes)
-      return [];
-    return Object.entries(this.spec.components.securitySchemes).map(([_name, scheme]) => {
-      const resolved = this.resolveRef(scheme);
-      return {
-        type: resolved.type,
-        scheme: "scheme" in resolved ? resolved.scheme : void 0,
-        bearerFormat: "bearerFormat" in resolved ? resolved.bearerFormat : void 0,
-        in: "in" in resolved ? resolved.in : void 0,
-        name: "name" in resolved ? resolved.name : void 0,
-        flows: "flows" in resolved ? resolved.flows : void 0,
-        openIdConnectUrl: "openIdConnectUrl" in resolved ? resolved.openIdConnectUrl : void 0
-      };
-    });
-  }
-  parseOperationSecurity(_security) {
-    return [];
-  }
-  mapOpenAPIType(type) {
-    switch (type) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "integer":
-        return "integer";
-      case "boolean":
-        return "boolean";
-      case "array":
-        return "array";
-      case "object":
-        return "object";
-      case "null":
-        return "null";
-      default:
-        return "any";
-    }
-  }
-  buildRefsMap() {
-    this.traverseAndMapRefs(this.spec, "");
-  }
-  traverseAndMapRefs(obj, currentPath) {
-    if (typeof obj !== "object" || obj === null)
-      return;
-    for (const [key, value] of Object.entries(obj)) {
-      const path = currentPath ? `${currentPath}/${key}` : key;
-      if (key === "$ref" && typeof value === "string") {
-        continue;
-      }
-      if (typeof value === "object") {
-        if (currentPath.includes("/components/")) {
-          this.refs.set(`#/${path}`, value);
-        }
-        this.traverseAndMapRefs(value, path);
-      }
-    }
-  }
-  resolveRef(item) {
-    if (typeof item === "object" && item !== null && "$ref" in item) {
-      const ref = item.$ref;
-      const resolved = this.refs.get(ref);
-      if (!resolved) {
-        throw new Error(`Could not resolve reference: ${ref}`);
-      }
-      return resolved;
-    }
-    return item;
-  }
-};
-async function parseOpenAPI(spec) {
-  const parser = new OpenAPIParser(spec);
-  return parser.parse();
-}
-async function loadOpenAPISpec(source) {
-  if (source.startsWith("http://") || source.startsWith("https://")) {
-    const response = await fetch(source);
-    if (!response.ok) {
-      throw new Error(`Failed to load OpenAPI spec from ${source}: ${response.statusText}`);
-    }
-    return response.json();
-  } else {
-    try {
-      return JSON.parse(source);
-    } catch {
-      try {
-        const absolutePath = (0, import_path.resolve)(source);
-        const content = await import_fs.promises.readFile(absolutePath, "utf8");
-        return JSON.parse(content);
-      } catch (fileError) {
-        throw new Error(`Failed to load OpenAPI spec: Not a valid URL, JSON string, or file path. ${fileError}`);
-      }
-    }
-  }
-}
-
-// src/codegen/openapi/type-generator.js
-var TypeScriptGenerator = class {
-  options;
-  generatedTypes = /* @__PURE__ */ new Set();
-  refMap = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.options = {
-      prefix: options.prefix || "",
-      suffix: options.suffix || "",
-      enumStyle: options.enumStyle || "union",
-      nullableStyle: options.nullableStyle || "undefined",
-      includeJSDoc: options.includeJSDoc !== false,
-      includeExamples: options.includeExamples !== false
-    };
-  }
-  generate(parsedAPI) {
-    this.generatedTypes.clear();
-    this.refMap.clear();
-    this.buildRefMap(parsedAPI);
-    return {
-      schemas: this.generateSchemas(parsedAPI.schemas),
-      endpoints: this.generateEndpointTypes(parsedAPI.endpoints),
-      parameters: this.generateParameterTypes(parsedAPI.endpoints),
-      responses: this.generateResponseTypes(parsedAPI.endpoints),
-      index: this.generateIndexFile()
-    };
-  }
-  buildRefMap(parsedAPI) {
-    parsedAPI.schemas.forEach((schema) => {
-      if (schema.ref) {
-        const typeName = this.extractTypeNameFromRef(schema.ref);
-        this.refMap.set(schema.ref, typeName);
-      }
-    });
-  }
-  generateSchemas(schemas) {
-    const types = [];
-    types.push(this.generateFileHeader("Schema Types"));
-    for (const schema of schemas) {
-      if (!schema.ref)
-        continue;
-      const typeName = this.refMap.get(schema.ref);
-      if (!typeName || this.generatedTypes.has(typeName))
-        continue;
-      const typeDefinition = this.generateSchemaType(schema, typeName);
-      types.push(typeDefinition);
-      this.generatedTypes.add(typeName);
-    }
-    return types.join("\n\n");
-  }
-  generateSchemaType(schema, typeName) {
-    const lines = [];
-    if (this.options.includeJSDoc && schema.description) {
-      lines.push(`/**`);
-      lines.push(` * ${schema.description}`);
-      if (this.options.includeExamples && schema.example) {
-        lines.push(` * @example ${JSON.stringify(schema.example)}`);
-      }
-      lines.push(` */`);
-    }
-    const typeContent = this.generateTypeContent(schema);
-    if (schema.type === "object" && !schema.enum) {
-      lines.push(`export interface ${typeName} ${typeContent}`);
-    } else {
-      lines.push(`export type ${typeName} = ${typeContent}`);
-    }
-    return lines.join("\n");
-  }
-  generateTypeContent(schema) {
-    switch (schema.type) {
-      case "object":
-        return this.generateObjectType(schema);
-      case "array":
-        return `${this.generateTypeContent(schema.items)}[]`;
-      case "string":
-        if (schema.enum) {
-          return this.generateEnumType(schema.enum);
-        }
-        return this.addNullable("string", schema.nullable);
-      case "number":
-      case "integer":
-        return this.addNullable("number", schema.nullable);
-      case "boolean":
-        return this.addNullable("boolean", schema.nullable);
-      case "null":
-        return "null";
-      case "any":
-        if (schema.ref) {
-          const refType = this.refMap.get(schema.ref);
-          return refType || "unknown";
-        }
-        return "unknown";
-      default:
-        return "unknown";
-    }
-  }
-  generateObjectType(schema) {
-    if (!schema.properties) {
-      return "{ [key: string]: unknown }";
-    }
-    const properties = [];
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-      const isRequired = schema.required?.includes(propName) || false;
-      const isOptional = !isRequired ? "?" : "";
-      const propType = this.generateTypeContent(propSchema);
-      let propDoc = "";
-      if (this.options.includeJSDoc && propSchema.description) {
-        propDoc = `  /** ${propSchema.description} */
-  `;
-      }
-      properties.push(`${propDoc}${propName}${isOptional}: ${propType}`);
-    }
-    return `{
-  ${properties.join("\n  ")}
-}`;
-  }
-  generateEnumType(enumValues) {
-    if (this.options.enumStyle === "enum") {
-      return enumValues.map((val) => `'${val}'`).join(" | ");
-    } else {
-      return enumValues.map((val) => `'${val}'`).join(" | ");
-    }
-  }
-  addNullable(type, nullable) {
-    if (!nullable)
-      return type;
-    switch (this.options.nullableStyle) {
-      case "null":
-        return `${type} | null`;
-      case "both":
-        return `${type} | null | undefined`;
-      case "undefined":
-      default:
-        return `${type} | undefined`;
-    }
-  }
-  generateEndpointTypes(endpoints) {
-    const types = [];
-    types.push(this.generateFileHeader("Endpoint Types"));
-    const endpointTypes = /* @__PURE__ */ new Set();
-    for (const endpoint of endpoints) {
-      const operationName = this.getOperationName(endpoint);
-      if (endpointTypes.has(operationName))
-        continue;
-      endpointTypes.add(operationName);
-      const requestType = this.generateRequestType(endpoint, operationName);
-      if (requestType) {
-        types.push(requestType);
-      }
-      const responseType = this.generateResponseType(endpoint, operationName);
-      if (responseType) {
-        types.push(responseType);
-      }
-    }
-    return types.join("\n\n");
-  }
-  generateRequestType(endpoint, operationName) {
-    const hasParams = endpoint.parameters.length > 0;
-    const hasBody = endpoint.requestBody !== void 0;
-    if (!hasParams && !hasBody)
-      return null;
-    const lines = [];
-    if (this.options.includeJSDoc) {
-      lines.push(`/**`);
-      lines.push(` * Request type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
-      if (endpoint.summary) {
-        lines.push(` * ${endpoint.summary}`);
-      }
-      lines.push(` */`);
-    }
-    const properties = [];
-    if (hasParams) {
-      const paramsByType = this.groupParametersByType(endpoint.parameters);
-      for (const [paramType, params] of Object.entries(paramsByType)) {
-        if (params.length === 0)
-          continue;
-        const paramProps = params.map((param) => {
-          const optional = param.required ? "" : "?";
-          const type = this.generateTypeContent(param.schema);
-          return `    ${param.name}${optional}: ${type}`;
-        });
-        properties.push(`  ${paramType}: {
-${paramProps.join("\n")}
-  }`);
-      }
-    }
-    if (hasBody && endpoint.requestBody) {
-      const bodyType = this.generateRequestBodyType(endpoint.requestBody);
-      const optional = endpoint.requestBody.required ? "" : "?";
-      properties.push(`  body${optional}: ${bodyType}`);
-    }
-    const typeName = `${this.formatTypeName(operationName)}Request`;
-    lines.push(`export interface ${typeName} {`);
-    lines.push(properties.join("\n"));
-    lines.push(`}`);
-    return lines.join("\n");
-  }
-  generateResponseType(endpoint, operationName) {
-    if (endpoint.responses.length === 0)
-      return null;
-    const lines = [];
-    if (this.options.includeJSDoc) {
-      lines.push(`/**`);
-      lines.push(` * Response type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
-      if (endpoint.summary) {
-        lines.push(` * ${endpoint.summary}`);
-      }
-      lines.push(` */`);
-    }
-    const responseTypes = [];
-    for (const response of endpoint.responses) {
-      if (response.content) {
-        for (const [mediaType, content] of Object.entries(response.content)) {
-          if (mediaType.includes("json")) {
-            const type = this.generateTypeContent(content.schema);
-            responseTypes.push(`{ status: ${response.statusCode}; data: ${type} }`);
-          }
-        }
-      } else {
-        responseTypes.push(`{ status: ${response.statusCode}; data: void }`);
-      }
-    }
-    const typeName = `${this.formatTypeName(operationName)}Response`;
-    const unionType = responseTypes.length > 1 ? responseTypes.join(" | ") : responseTypes[0] || "void";
-    lines.push(`export type ${typeName} = ${unionType}`);
-    return lines.join("\n");
-  }
-  generateRequestBodyType(requestBody) {
-    const jsonContent = requestBody.content["application/json"] || requestBody.content["application/vnd.api+json"] || Object.values(requestBody.content)[0];
-    if (!jsonContent)
-      return "unknown";
-    return this.generateTypeContent(jsonContent.schema);
-  }
-  generateParameterTypes(_endpoints) {
-    const types = [];
-    types.push(this.generateFileHeader("Parameter Types"));
-    return types.join("\n\n");
-  }
-  generateResponseTypes(_endpoints) {
-    const types = [];
-    types.push(this.generateFileHeader("Response Types"));
-    return types.join("\n\n");
-  }
-  generateIndexFile() {
-    const lines = [];
-    lines.push(this.generateFileHeader("Generated API Types"));
-    lines.push("");
-    lines.push("// Schema exports");
-    lines.push("export * from './schemas'");
-    lines.push("");
-    lines.push("// Endpoint exports");
-    lines.push("export * from './endpoints'");
-    lines.push("");
-    lines.push("// Parameter exports");
-    lines.push("export * from './parameters'");
-    lines.push("");
-    lines.push("// Response exports");
-    lines.push("export * from './responses'");
-    return lines.join("\n");
-  }
-  generateFileHeader(title) {
-    return `/**
- * ${title}
- * 
- * Auto-generated from OpenAPI specification
- * Do not edit manually - regenerate using the OpenAPI type generator
- */`;
-  }
-  getOperationName(endpoint) {
-    if (endpoint.operationId) {
-      return endpoint.operationId;
-    }
-    const pathParts = endpoint.path.split("/").filter((part) => part && !part.startsWith("{")).map((part) => this.capitalize(part));
-    return `${endpoint.method}${pathParts.join("")}`;
-  }
-  formatTypeName(name) {
-    const formatted = this.capitalize(name);
-    return `${this.options.prefix}${formatted}${this.options.suffix}`;
-  }
-  extractTypeNameFromRef(ref) {
-    const parts = ref.split("/");
-    const name = parts[parts.length - 1];
-    return this.formatTypeName(name);
-  }
-  groupParametersByType(parameters) {
-    const grouped = {
-      path: [],
-      query: [],
-      header: [],
-      cookie: []
-    };
-    for (const param of parameters) {
-      grouped[param.in].push(param);
-    }
-    return grouped;
-  }
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-};
-function generateTypes(parsedAPI, options) {
-  const generator = new TypeScriptGenerator(options);
-  return generator.generate(parsedAPI);
-}
-
-// src/codegen/openapi/client-generator.js
-var APIClientGenerator = class {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      clientType: options.clientType || "axios",
-      baseUrl: options.baseUrl || "",
-      includeAuth: options.includeAuth !== false,
-      authType: options.authType || "bearer",
-      timeout: options.timeout || 1e4,
-      retries: options.retries || 3,
-      includeInterceptors: options.includeInterceptors !== false
-    };
-  }
-  generate(parsedAPI) {
-    return {
-      client: this.generateClientSetup(),
-      methods: this.generateApiMethods(parsedAPI.endpoints),
-      types: this.generateClientTypes(),
-      config: this.generateConfiguration(),
-      index: this.generateIndexFile()
-    };
-  }
-  generateClientSetup() {
-    if (this.options.clientType === "axios") {
-      return this.generateAxiosClient();
-    } else {
-      return this.generateFetchClient();
-    }
-  }
-  generateAxiosClient() {
-    return `/**
- * Axios API Client
- * 
- * Auto-generated API client with interceptors and error handling
- */
-
-import axios, { AxiosInstance, AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import { APIClientConfig, RequestOptions, APIError } from './types'
-
-export class APIClient {
-  private client: AxiosInstance
-  private config: APIClientConfig
-
-  constructor(config: APIClientConfig) {
-    this.config = config
-    this.client = this.createAxiosInstance()
-    this.setupInterceptors()
-  }
-
-  private createAxiosInstance(): AxiosInstance {
-    return axios.create({
-      baseURL: this.config.baseUrl,
-      timeout: this.config.timeout || ${this.options.timeout},
-      headers: {
-        'Content-Type': 'application/json',
-        ...this.config.defaultHeaders
-      }
-    })
-  }
-
-  ${this.options.includeInterceptors ? this.generateAxiosInterceptors() : ""}
-
-  private async makeRequest<T>(
-    method: string,
-    url: string,
-    options: RequestOptions = {}
-  ): Promise<T> {
-    try {
-      const config: AxiosRequestConfig = {
-        method: method as any,
-        url,
-        ...options.config
-      }
-
-      if (options.params) {
-        config.params = options.params
-      }
-
-      if (options.data) {
-        config.data = options.data
-      }
-
-      if (options.headers) {
-        config.headers = { ...config.headers, ...options.headers }
-      }
-
-      ${this.options.includeAuth ? this.generateAuthInjection() : ""}
-
-      const response: AxiosResponse<T> = await this.client.request(config)
-      return response.data
-    } catch (error) {
-      throw this.handleError(error as AxiosError)
-    }
-  }
-
-  private handleError(error: AxiosError): APIError {
-    const apiError: APIError = {
-      message: error.message,
-      status: error.response?.status,
-      statusText: error.response?.statusText,
-      data: error.response?.data,
-      config: {
-        url: error.config?.url,
-        method: error.config?.method?.toUpperCase(),
-        headers: error.config?.headers
-      }
-    }
-
-    if (this.config.onError) {
-      this.config.onError(apiError)
-    }
-
-    return apiError
-  }
-
-  public get<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('GET', url, options)
-  }
-
-  public post<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('POST', url, { ...options, data })
-  }
-
-  public put<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PUT', url, { ...options, data })
-  }
-
-  public patch<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PATCH', url, { ...options, data })
-  }
-
-  public delete<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('DELETE', url, options)
-  }
-}`;
-  }
-  generateFetchClient() {
-    return `/**
- * Fetch API Client
- * 
- * Auto-generated API client using native fetch with error handling
- */
-
-import { APIClientConfig, RequestOptions, APIError } from './types'
-
-export class APIClient {
-  private config: APIClientConfig
-
-  constructor(config: APIClientConfig) {
-    this.config = config
-  }
-
-  private async makeRequest<T>(
-    method: string,
-    url: string,
-    options: RequestOptions = {}
-  ): Promise<T> {
-    try {
-      const fullUrl = this.buildUrl(url, options.params)
-      
-      const fetchOptions: RequestInit = {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          ...this.config.defaultHeaders,
-          ...options.headers
-        },
-        signal: options.signal
-      }
-
-      if (options.data && method !== 'GET') {
-        fetchOptions.body = JSON.stringify(options.data)
-      }
-
-      ${this.options.includeAuth ? this.generateFetchAuthInjection() : ""}
-
-      const response = await fetch(fullUrl, fetchOptions)
-
-      if (!response.ok) {
-        throw await this.createErrorFromResponse(response)
-      }
-
-      const contentType = response.headers.get('content-type')
-      if (contentType && contentType.includes('application/json')) {
-        return await response.json()
-      }
-
-      return await response.text() as any
-    } catch (error) {
-      if (error instanceof APIError) {
-        throw error
-      }
-      throw this.createGenericError(error as Error)
-    }
-  }
-
-  private buildUrl(path: string, params?: Record<string, any>): string {
-    const url = new URL(path, this.config.baseUrl)
-    
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          url.searchParams.append(key, String(value))
-        }
-      })
-    }
-
-    return url.toString()
-  }
-
-  private async createErrorFromResponse(response: Response): Promise<APIError> {
-    let data: any
-    try {
-      data = await response.json()
-    } catch {
-      data = await response.text()
-    }
-
-    const error: APIError = {
-      message: data?.message || response.statusText || 'Request failed',
-      status: response.status,
-      statusText: response.statusText,
-      data,
-      config: {
-        url: response.url,
-        method: 'Unknown'
-      }
-    }
-
-    if (this.config.onError) {
-      this.config.onError(error)
-    }
-
-    return error
-  }
-
-  private createGenericError(error: Error): APIError {
-    const apiError: APIError = {
-      message: error.message,
-      config: {}
-    }
-
-    if (this.config.onError) {
-      this.config.onError(apiError)
-    }
-
-    return apiError
-  }
-
-  public get<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('GET', url, options)
-  }
-
-  public post<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('POST', url, { ...options, data })
-  }
-
-  public put<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PUT', url, { ...options, data })
-  }
-
-  public patch<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PATCH', url, { ...options, data })
-  }
-
-  public delete<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('DELETE', url, options)
-  }
-}`;
-  }
-  generateAxiosInterceptors() {
-    return `
-  private setupInterceptors(): void {
-    // Request interceptor
-    this.client.interceptors.request.use(
-      (config) => {
-        if (this.config.onRequest) {
-          return this.config.onRequest(config) || config
-        }
-        return config
-      },
-      (error) => {
-        if (this.config.onRequestError) {
-          this.config.onRequestError(error)
-        }
-        return Promise.reject(error)
-      }
-    )
-
-    // Response interceptor
-    this.client.interceptors.response.use(
-      (response) => {
-        if (this.config.onResponse) {
-          return this.config.onResponse(response) || response
-        }
-        return response
-      },
-      async (error) => {
-        if (this.config.onResponseError) {
-          const result = await this.config.onResponseError(error)
-          if (result) {
-            return result
-          }
-        }
-
-        // Auto-retry logic
-        if (this.shouldRetry(error)) {
-          return this.retryRequest(error.config)
-        }
-
-        return Promise.reject(error)
-      }
-    )
-  }
-
-  private shouldRetry(error: AxiosError): boolean {
-    const retryCount = (error.config as any)?._retryCount || 0
-    const maxRetries = this.config.retries || ${this.options.retries}
-    
-    return (
-      retryCount < maxRetries &&
-      (!error.response || error.response.status >= 500) &&
-      error.code !== 'ECONNABORTED'
-    )
-  }
-
-  private async retryRequest(config: any): Promise<any> {
-    config._retryCount = (config._retryCount || 0) + 1
-    
-    // Exponential backoff
-    const delay = Math.pow(2, config._retryCount) * 1000
-    await new Promise(resolve => setTimeout(resolve, delay))
-    
-    return this.client.request(config)
-  }`;
-  }
-  generateAuthInjection() {
-    switch (this.options.authType) {
-      case "bearer":
-        return `
-      // Inject bearer token if available
-      if (this.config.getAuthToken) {
-        const token = await this.config.getAuthToken()
-        if (token) {
-          config.headers = {
-            ...config.headers,
-            Authorization: \`Bearer \${token}\`
-          }
-        }
-      }`;
-      case "apiKey":
-        return `
-      // Inject API key if available
-      if (this.config.getApiKey) {
-        const apiKey = await this.config.getApiKey()
-        if (apiKey) {
-          if (this.config.apiKeyHeader) {
-            config.headers = {
-              ...config.headers,
-              [this.config.apiKeyHeader]: apiKey
-            }
-          } else {
-            config.params = { ...config.params, api_key: apiKey }
-          }
-        }
-      }`;
-      case "basic":
-        return `
-      // Inject basic auth if available
-      if (this.config.getBasicAuth) {
-        const auth = await this.config.getBasicAuth()
-        if (auth) {
-          const encoded = btoa(\`\${auth.username}:\${auth.password}\`)
-          config.headers = {
-            ...config.headers,
-            Authorization: \`Basic \${encoded}\`
-          }
-        }
-      }`;
-      default:
-        return "";
-    }
-  }
-  generateFetchAuthInjection() {
-    switch (this.options.authType) {
-      case "bearer":
-        return `
-      // Inject bearer token if available
-      if (this.config.getAuthToken) {
-        const token = await this.config.getAuthToken()
-        if (token) {
-          fetchOptions.headers = {
-            ...fetchOptions.headers,
-            Authorization: \`Bearer \${token}\`
-          }
-        }
-      }`;
-      case "apiKey":
-        return `
-      // Inject API key if available
-      if (this.config.getApiKey) {
-        const apiKey = await this.config.getApiKey()
-        if (apiKey && this.config.apiKeyHeader) {
-          fetchOptions.headers = {
-            ...fetchOptions.headers,
-            [this.config.apiKeyHeader]: apiKey
-          }
-        }
-      }`;
-      default:
-        return "";
-    }
-  }
-  generateApiMethods(endpoints) {
-    const methods = [];
-    methods.push(this.generateFileHeader("API Methods"));
-    methods.push("");
-    methods.push("import { APIClient } from './client'");
-    methods.push("import * as Types from './types'");
-    methods.push("");
-    methods.push("export class APIService {");
-    methods.push("  constructor(private client: APIClient) {}");
-    methods.push("");
-    const groupedEndpoints = this.groupEndpoints(endpoints);
-    for (const [group, groupEndpoints] of Object.entries(groupedEndpoints)) {
-      methods.push(`  // ${group} methods`);
-      for (const endpoint of groupEndpoints) {
-        const method = this.generateEndpointMethod(endpoint);
-        methods.push(method);
-        methods.push("");
-      }
-    }
-    methods.push("}");
-    return methods.join("\n");
-  }
-  generateEndpointMethod(endpoint) {
-    const methodName = this.getMethodName(endpoint);
-    const pathWithParams = this.generatePathWithParams(endpoint);
-    const httpMethod = endpoint.method.toLowerCase();
-    const lines = [];
-    lines.push("  /**");
-    if (endpoint.summary) {
-      lines.push(`   * ${endpoint.summary}`);
-    }
-    if (endpoint.description) {
-      lines.push(`   * ${endpoint.description}`);
-    }
-    lines.push(`   * @param options Request options`);
-    lines.push("   */");
-    const hasPathParams = endpoint.parameters.some((p) => p.in === "path");
-    const hasQueryParams = endpoint.parameters.some((p) => p.in === "query");
-    const hasBody = endpoint.requestBody !== void 0;
-    let params = "options: RequestOptions = {}";
-    if (hasPathParams) {
-      const pathParams = endpoint.parameters.filter((p) => p.in === "path").map((p) => `${p.name}: ${this.getParameterType(p)}`).join(", ");
-      params = `${pathParams}, ${params}`;
-    }
-    const responseType = this.getResponseType(endpoint);
-    lines.push(`  async ${methodName}(${params}): Promise<${responseType}> {`);
-    const urlConstruction = hasPathParams ? `const url = \`${pathWithParams}\`` : `const url = '${endpoint.path}'`;
-    lines.push(`    ${urlConstruction}`);
-    if (hasQueryParams) {
-      lines.push("    const queryParams = {");
-      endpoint.parameters.filter((p) => p.in === "query").forEach((p) => {
-        lines.push(`      ${p.name}: options.${p.name},`);
-      });
-      lines.push("    }");
-      lines.push("    options.params = { ...queryParams, ...options.params }");
-    }
-    if (hasBody) {
-      lines.push(`    return this.client.${httpMethod}<${responseType}>(url, options.data, options)`);
-    } else {
-      lines.push(`    return this.client.${httpMethod}<${responseType}>(url, options)`);
-    }
-    lines.push("  }");
-    return lines.join("\n");
-  }
-  generateClientTypes() {
-    const authTypes = this.generateAuthTypes();
-    return `/**
- * API Client Types
- * 
- * Configuration and utility types for the generated API client
- */
-
-${this.options.clientType === "axios" ? "import { AxiosRequestConfig, AxiosResponse } from 'axios'" : ""}
-
-export interface APIClientConfig {
-  baseUrl: string
-  timeout?: number
-  defaultHeaders?: Record<string, string>
-  retries?: number
-  ${this.options.includeAuth ? authTypes : ""}
-  onRequest?: (config: any) => any
-  onRequestError?: (error: any) => void
-  onResponse?: (response: any) => any
-  onResponseError?: (error: any) => Promise<any> | any
-  onError?: (error: APIError) => void
-}
-
-export interface RequestOptions {
-  params?: Record<string, any>
-  data?: any
-  headers?: Record<string, string>
-  config?: any
-  signal?: AbortSignal
-  [key: string]: any
-}
-
-export interface APIError {
-  message: string
-  status?: number
-  statusText?: string
-  data?: any
-  config: {
-    url?: string
-    method?: string
-    headers?: any
-  }
-}`;
-  }
-  generateAuthTypes() {
-    switch (this.options.authType) {
-      case "bearer":
-        return "getAuthToken?: () => Promise<string | null> | string | null";
-      case "apiKey":
-        return `getApiKey?: () => Promise<string | null> | string | null
-  apiKeyHeader?: string`;
-      case "basic":
-        return "getBasicAuth?: () => Promise<{ username: string; password: string } | null> | { username: string; password: string } | null";
-      default:
-        return "";
-    }
-  }
-  generateConfiguration() {
-    return `/**
- * API Client Configuration
- * 
- * Default configuration and factory functions
- */
-
-import { APIClient } from './client'
-import { APIService } from './methods'
-import { APIClientConfig } from './types'
-
-export function createAPIClient(config: APIClientConfig): APIService {
-  const client = new APIClient(config)
-  return new APIService(client)
-}
-
-export const defaultConfig: Partial<APIClientConfig> = {
-  timeout: ${this.options.timeout},
-  retries: ${this.options.retries},
-  defaultHeaders: {
-    'Content-Type': 'application/json'
-  }
-}`;
-  }
-  generateIndexFile() {
-    return `/**
- * Generated API Client
- * 
- * Auto-generated from OpenAPI specification
- */
-
-export * from './client'
-export * from './methods'
-export * from './types'
-export * from './config'
-export { createAPIClient, defaultConfig } from './config'
-
-// Singleton instance for convenient usage
-export const apiClient = createAPIClient({
-  baseUrl: process.env.VITE_API_URL || '${this.options.baseUrl || "http://localhost:8080"}',
-  timeout: ${this.options.timeout},
-  defaultHeaders: {
-    'Content-Type': 'application/json'
-  }
-})`;
-  }
-  generateFileHeader(title) {
-    return `/**
- * ${title}
- * 
- * Auto-generated from OpenAPI specification
- * Do not edit manually
- */`;
-  }
-  getMethodName(endpoint) {
-    if (endpoint.operationId) {
-      return this.camelCase(endpoint.operationId);
-    }
-    const pathParts = endpoint.path.split("/").filter((part) => part && !part.startsWith("{")).map((part) => this.capitalize(part));
-    return this.camelCase(`${endpoint.method}_${pathParts.join("_")}`);
-  }
-  generatePathWithParams(endpoint) {
-    return endpoint.path.replace(/{([^}]+)}/g, "${$1}");
-  }
-  getParameterType(param) {
-    switch (param.schema.type) {
-      case "string":
-        return "string";
-      case "number":
-      case "integer":
-        return "number";
-      case "boolean":
-        return "boolean";
-      default:
-        return "any";
-    }
-  }
-  getResponseType(endpoint) {
-    const successResponse = endpoint.responses.find((r) => r.statusCode.startsWith("2") || r.statusCode === "default");
-    if (!successResponse?.content) {
-      return "void";
-    }
-    const jsonContent = successResponse.content["application/json"];
-    if (!jsonContent) {
-      return "any";
-    }
-    return "any";
-  }
-  groupEndpoints(endpoints) {
-    const groups = {};
-    for (const endpoint of endpoints) {
-      const group = endpoint.tags?.[0] || "default";
-      if (!groups[group]) {
-        groups[group] = [];
-      }
-      groups[group].push(endpoint);
-    }
-    return groups;
-  }
-  camelCase(str) {
-    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^./, (char) => char.toLowerCase());
-  }
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-};
-function generateAPIClient(parsedAPI, options) {
-  const generator = new APIClientGenerator(options);
-  return generator.generate(parsedAPI);
-}
-
-// src/codegen/openapi/hook-config.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var DEFAULT_CONFIG = {
-  version: "1.0.0",
-  nameOverrides: {},
-  reviewedNames: [],
-  patterns: {
-    removeDoubleWords: true,
-    smartCasing: true,
-    deduplicateSegments: true
-  }
-};
-var HookConfigManager = class {
-  configPath;
-  config = DEFAULT_CONFIG;
-  constructor(configPath = "./hooks.config.json") {
-    this.configPath = (0, import_path2.resolve)(configPath);
-  }
-  async load() {
-    try {
-      const content = await import_fs2.promises.readFile(this.configPath, "utf8");
-      this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
-    } catch (error) {
-      this.config = DEFAULT_CONFIG;
-    }
-  }
-  async save() {
-    const content = JSON.stringify(this.config, null, 2);
-    await import_fs2.promises.writeFile(this.configPath, content, "utf8");
-  }
-  getOverride(operationId) {
-    return this.config.nameOverrides[operationId];
-  }
-  addOverride(override) {
-    this.config.nameOverrides[override.original] = override.override;
-    this.config.reviewedNames.push({
-      ...override,
-      approvedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  getPatterns() {
-    return this.config.patterns;
-  }
-  updateStatistics(stats) {
-    this.config.statistics = {
-      ...this.config.statistics,
-      ...stats,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  getReviewedNames() {
-    return this.config.reviewedNames;
-  }
-  hasBeenReviewed(operationId) {
-    return operationId in this.config.nameOverrides;
-  }
-};
-
-// src/codegen/openapi/confidence-scorer.ts
-var ConfidenceScorer = class {
-  /**
-   * Score a generated hook name based on various quality indicators
-   */
-  scoreHookName(generatedName, originalOperationId, path, method) {
-    const issues = [];
-    const suggestions = [];
-    let score = 100;
-    if (!this.isProperCamelCase(generatedName)) {
-      score -= 20;
-      issues.push("Improper camelCase formatting");
-    }
-    if (this.hasConsecutiveUppercase(generatedName)) {
-      score -= 30;
-      issues.push("Consecutive uppercase letters suggest concatenation issues");
-      suggestions.push(this.suggestFixForConsecutiveUppercase(generatedName));
-    }
-    const nameLength = generatedName.length;
-    if (nameLength > 30) {
-      score -= 20;
-      issues.push(`Name is too long (${nameLength} chars)`);
-    }
-    if (this.hasRepeatedWords(generatedName)) {
-      score -= 25;
-      issues.push("Contains repeated word segments");
-    }
-    if (this.matchesCommonPattern(generatedName, method)) {
-      score += 10;
-      score = Math.min(score, 100);
-    }
-    if (this.hasWordBoundaryIssues(generatedName)) {
-      score -= 15;
-      issues.push("Potential word boundary issues");
-    }
-    let confidence;
-    if (score >= 80) {
-      confidence = "high";
-    } else if (score >= 60) {
-      confidence = "medium";
-    } else {
-      confidence = "low";
-    }
-    return {
-      name: generatedName,
-      confidence,
-      score,
-      issues,
-      suggestions: suggestions.filter((s) => s !== generatedName)
-    };
-  }
-  isProperCamelCase(name) {
-    if (!name.startsWith("use")) return false;
-    const afterUse = name.substring(3);
-    return /^[A-Z][a-zA-Z0-9]*$/.test(afterUse);
-  }
-  hasConsecutiveUppercase(name) {
-    return /[A-Z]{2,}[a-z]/.test(name) || /[a-z][A-Z]{2,}/.test(name);
-  }
-  hasRepeatedWords(name) {
-    const words = this.camelCaseToWords(name).map((w) => w.toLowerCase());
-    const uniqueWords = new Set(words);
-    return words.length > uniqueWords.size + 1;
-  }
-  matchesCommonPattern(name, method) {
-    const commonPatterns = {
-      get: /^use[A-Z][a-zA-Z]+$/,
-      post: /^useCreate[A-Z][a-zA-Z]+$/,
-      put: /^useUpdate[A-Z][a-zA-Z]+$/,
-      patch: /^useUpdate[A-Z][a-zA-Z]+$/,
-      delete: /^useDelete[A-Z][a-zA-Z]+$/
-    };
-    const pattern = commonPatterns[method];
-    return pattern ? pattern.test(name) : false;
-  }
-  hasWordBoundaryIssues(name) {
-    const afterUse = name.substring(3);
-    const knownPrefixes = ["Create", "Update", "Delete", "Get", "List", "Fetch", "Assign", "Reassign"];
-    for (const prefix of knownPrefixes) {
-      if (afterUse.startsWith(prefix)) {
-        const remaining = afterUse.substring(prefix.length);
-        if (/[a-z]{2,}[A-Z]/.test(remaining)) {
-          return true;
-        }
-      }
-    }
-    if (/[a-z]{3,}[A-Z]/.test(afterUse)) {
-      return true;
-    }
-    if (/[A-Z][a-z]+[a-z][A-Z]/.test(afterUse)) {
-      return true;
-    }
-    return false;
-  }
-  suggestFixForConsecutiveUppercase(name) {
-    let suggestion = name;
-    const knownFixes = {
-      "useAssignRolesusersUserRoles": "useAssignUserRoles",
-      "useReassignBudgettransactionsReassignBudget": "useReassignTransactionBudget",
-      "useCategorySubcategories": "useCreateSubcategory"
-    };
-    if (knownFixes[name]) {
-      return knownFixes[name];
-    }
-    suggestion = suggestion.replace(/([a-z]{2,})([A-Z])/g, (match, p1, p2) => {
-      if (p1.endsWith("roles") || p1.endsWith("users") || p1.endsWith("budget")) {
-        return p1 + p2;
-      }
-      return match;
-    });
-    const parts = this.camelCaseToWords(suggestion);
-    if (parts.length > 4) {
-      const action = parts[1];
-      const resources = parts.slice(2);
-      const uniqueResources = [...new Set(resources.map((r) => r.toLowerCase()))];
-      if (uniqueResources.length === 1) {
-        return `use${action}${resources[resources.length - 1]}`;
-      }
-    }
-    return suggestion;
-  }
-  camelCaseToWords(str) {
-    return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(" ").filter((w) => w.length > 0);
-  }
-  /**
-   * Generate a confidence report for review
-   */
-  generateReport(scoredNames) {
-    const byConfidence = {
-      high: scoredNames.filter((s) => s.confidence === "high"),
-      medium: scoredNames.filter((s) => s.confidence === "medium"),
-      low: scoredNames.filter((s) => s.confidence === "low")
-    };
-    let report = "# Hook Name Generation Report\n\n";
-    report += `Generated ${scoredNames.length} hooks
-
-`;
-    report += `- High confidence: ${byConfidence.high.length}
-`;
-    report += `- Medium confidence: ${byConfidence.medium.length}
-`;
-    report += `- Low confidence: ${byConfidence.low.length}
-
-`;
-    if (byConfidence.low.length > 0) {
-      report += "## Low Confidence Names (Review Recommended)\n\n";
-      for (const scored of byConfidence.low) {
-        report += `### ${scored.name}
-`;
-        report += `- Score: ${scored.score}/100
-`;
-        report += `- Issues: ${scored.issues.join(", ")}
-`;
-        if (scored.suggestions.length > 0) {
-          report += `- Suggestions: ${scored.suggestions.join(", ")}
-`;
-        }
-        report += "\n";
-      }
-    }
-    if (byConfidence.medium.length > 0) {
-      report += "## Medium Confidence Names (Optional Review)\n\n";
-      for (const scored of byConfidence.medium) {
-        report += `- ${scored.name} (${scored.score}/100)
-`;
-        if (scored.issues.length > 0) {
-          report += `  Issues: ${scored.issues.join(", ")}
-`;
-        }
-      }
-      report += "\n";
-    }
-    return report;
-  }
-};
-
-// src/codegen/openapi/bulk-types.ts
-function isBulkOperation(path, method, requestBody) {
-  const bulkPatterns = [
-    /\/bulk[-_]?delete$/i,
-    /\/bulk[-_]?update$/i,
-    /\/bulk[-_]?create$/i,
-    /\/batch$/i,
-    /\/bulk$/i,
-    /\/multiple$/i
-  ];
-  if (bulkPatterns.some((pattern) => pattern.test(path))) {
-    return true;
-  }
-  if (requestBody && typeof requestBody === "object") {
-    const body = requestBody;
-    if (body.content?.["application/json"]?.schema) {
-      const schema = body.content["application/json"].schema;
-      return schema.type === "array" && !!schema.items;
-    }
-    if ("type" in requestBody) {
-      const bodyType = requestBody;
-      return bodyType.type === "array" && !!bodyType.items;
-    }
-  }
-  return false;
-}
-function detectBulkOperationType2(path, method) {
-  const lowercasePath = path.toLowerCase();
-  const lowercaseMethod = method.toLowerCase();
-  if (lowercasePath.includes("delete") || lowercaseMethod === "delete") {
-    return "delete";
-  }
-  if (lowercasePath.includes("update") || lowercaseMethod === "put" || lowercaseMethod === "patch") {
-    return "update";
-  }
-  if (lowercasePath.includes("create") || lowercaseMethod === "post") {
-    return "create";
-  }
-  if (lowercasePath.includes("batch") || lowercasePath.includes("bulk")) {
-    return "mixed";
-  }
-  return null;
-}
-function generateBulkOperationName(resource, operationType) {
-  const cleanResource = resource.replace(/[^a-zA-Z0-9]/g, "");
-  const singular = cleanResource.endsWith("s") ? cleanResource.slice(0, -1) : cleanResource;
-  const capitalizedSingular = capitalize(singular);
-  switch (operationType) {
-    case "delete":
-      return `bulkDelete${capitalizedSingular}s`;
-    case "update":
-      return `bulkUpdate${capitalizedSingular}s`;
-    case "create":
-      return `bulkCreate${capitalizedSingular}s`;
-    case "mixed":
-      return `bulk${capitalizedSingular}Operations`;
-    default:
-      return `bulk${capitalizedSingular}s`;
-  }
-}
-function capitalize(str) {
-  if (!str) return "";
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-
-// src/codegen/openapi/bulk-hook-generator.ts
-var BulkHookGenerator = class {
-  /**
-   * Generate a bulk mutation hook with progress tracking and retry logic
-   */
-  generateBulkMutationHook(endpoint, hookName, operationName) {
-    const bulkType = detectBulkOperationType2(endpoint.path, endpoint.method);
-    const lines = [];
-    lines.push("/**");
-    if (endpoint.summary) {
-      lines.push(` * ${endpoint.summary}`);
-    }
-    if (endpoint.description) {
-      lines.push(` * ${endpoint.description}`);
-    }
-    lines.push(" * @param options Mutation options with bulk operation support");
-    lines.push(" */");
-    const resource = endpoint.tags?.[0] || "default";
-    lines.push(`export function ${hookName}(`);
-    lines.push(`  options?: UseMutationOptions<BulkOperationResponse, any, BulkOperationRequest> & BulkMutationOptions`);
-    lines.push(") {");
-    lines.push("  const queryClient = useQueryClient()");
-    lines.push("  ");
-    lines.push("  return useMutation({");
-    lines.push("    mutationFn: async (request: BulkOperationRequest) => {");
-    lines.push("      // Transform request if needed");
-    lines.push("      const transformedRequest = options?.transformRequest ");
-    lines.push("        ? options.transformRequest(request) ");
-    lines.push("        : request");
-    lines.push("      ");
-    lines.push("      // Simulate progress updates for demo");
-    lines.push("      if (options?.onProgress) {");
-    lines.push("        options.onProgress({");
-    lines.push("          total: request.ids.length,");
-    lines.push("          processed: 0,");
-    lines.push("          succeeded: 0,");
-    lines.push("          failed: 0,");
-    lines.push("          percentage: 0,");
-    lines.push("          status: 'processing'");
-    lines.push("        })");
-    lines.push("      }");
-    lines.push("      ");
-    lines.push(`      const response = await apiClient.${this.camelCase(operationName)}(transformedRequest)`);
-    lines.push("      ");
-    lines.push("      // Transform response if needed");
-    lines.push("      const transformedResponse = options?.transformResponse");
-    lines.push("        ? options.transformResponse(response)");
-    lines.push("        : response");
-    lines.push("      ");
-    lines.push("      // Final progress update");
-    lines.push("      if (options?.onProgress && transformedResponse) {");
-    lines.push("        options.onProgress({");
-    lines.push("          total: transformedResponse.summary?.total || request.ids.length,");
-    lines.push("          processed: transformedResponse.summary?.total || request.ids.length,");
-    lines.push("          succeeded: transformedResponse.summary?.succeeded || 0,");
-    lines.push("          failed: transformedResponse.summary?.failed || 0,");
-    lines.push("          percentage: 100,");
-    lines.push("          status: 'completed'");
-    lines.push("        })");
-    lines.push("      }");
-    lines.push("      ");
-    lines.push("      return transformedResponse");
-    lines.push("    },");
-    lines.push(this.generateBulkOptimisticUpdate(resource, bulkType));
-    lines.push(this.generateBulkCacheInvalidation(resource));
-    lines.push("    onSuccess: (data, variables, context) => {");
-    lines.push("      // Handle partial success");
-    lines.push("      if (data.failed.length > 0 && options?.onPartialSuccess) {");
-    lines.push("        options.onPartialSuccess(data)");
-    lines.push("      }");
-    lines.push("      ");
-    lines.push("      // Call original onSuccess if provided");
-    lines.push("      options?.onSuccess?.(data, variables, context)");
-    lines.push("    },");
-    lines.push("    retry: (failureCount, error) => {");
-    lines.push("      // Use custom retry config if provided");
-    lines.push("      if (options?.retry?.maxAttempts !== undefined) {");
-    lines.push("        return failureCount < options.retry.maxAttempts");
-    lines.push("      }");
-    lines.push("      // Default: retry up to 3 times for bulk operations");
-    lines.push("      return failureCount < 3");
-    lines.push("    },");
-    lines.push("    retryDelay: (attemptIndex) => {");
-    lines.push("      // Use custom retry delay if provided");
-    lines.push("      if (options?.retry?.initialDelay) {");
-    lines.push("        const delay = Math.min(");
-    lines.push("          options.retry.initialDelay * Math.pow(options.retry.backoffMultiplier || 2, attemptIndex),");
-    lines.push("          options.retry.maxDelay || 30000");
-    lines.push("        )");
-    lines.push("        return delay");
-    lines.push("      }");
-    lines.push("      // Default exponential backoff: 1s, 2s, 4s...");
-    lines.push("      return Math.min(1000 * Math.pow(2, attemptIndex), 30000)");
-    lines.push("    },");
-    lines.push("    ...options");
-    lines.push("  })");
-    lines.push("}");
-    return lines.join("\n");
-  }
-  /**
-   * Generate optimistic updates for bulk operations
-   */
-  generateBulkOptimisticUpdate(resource, bulkType) {
-    switch (bulkType) {
-      case "delete":
-        return `    onMutate: async (request: BulkOperationRequest) => {
-      // Cancel outgoing refetches
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      // Snapshot previous value
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically remove items
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return old.filter((item: any) => !request.ids.includes(item.id))
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      // Rollback on error
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      case "update":
-        return `    onMutate: async (request: BulkOperationRequest) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically update items
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return old.map((item: any) => 
-            request.ids.includes(item.id) 
-              ? { ...item, ...request.data } 
-              : item
-          )
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      case "create":
-        return `    onMutate: async (request: BulkOperationRequest) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically add items (if data provided)
-      if (request.data && Array.isArray(request.data)) {
-        queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-          if (Array.isArray(old)) {
-            return [...old, ...request.data]
-          }
-          return old
-        })
-      }
-      
-      return { previousData }
-    },
-    onError: (err: any, request: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      default:
-        return "";
-    }
-  }
-  /**
-   * Generate cache invalidation for bulk operations
-   */
-  generateBulkCacheInvalidation(resource) {
-    return `    onSettled: () => {
-      // Invalidate related queries after bulk operation
-      queryClient.invalidateQueries({ queryKey: queryKeys.${resource}() })
-      queryClient.invalidateQueries({ queryKey: queryKeys.all })
-    },`;
-  }
-  /**
-   * Generate bulk mutation hook name
-   */
-  generateBulkMutationHookName(endpoint, resourceName) {
-    const requestBody = endpoint.requestBody;
-    if (!isBulkOperation(endpoint.path, endpoint.method, requestBody)) {
-      return null;
-    }
-    const bulkType = detectBulkOperationType2(endpoint.path, endpoint.method);
-    if (bulkType && resourceName) {
-      const bulkName = generateBulkOperationName(resourceName, bulkType);
-      return `use${this.capitalize(bulkName)}`;
-    }
-    return null;
-  }
-  /**
-   * Check if endpoint is a bulk operation
-   */
-  isBulkEndpoint(endpoint) {
-    const requestBody = endpoint.requestBody;
-    return isBulkOperation(endpoint.path, endpoint.method, requestBody);
-  }
-  /**
-   * Helper to convert to camelCase
-   */
-  camelCase(str) {
-    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^./, (char) => char.toLowerCase());
-  }
-  /**
-   * Helper to capitalize string
-   */
-  capitalize(str) {
-    if (str.includes("_")) {
-      return str.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-    }
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-};
-
-// src/codegen/openapi/hook-generator.js
-var ReactHookGenerator = class {
-  options;
-  configManager;
-  confidenceScorer;
-  bulkHookGenerator;
-  scoredNames = [];
-  resourceConfigs = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.options = {
-      queryKeyPrefix: options.queryKeyPrefix || "api",
-      includeInfiniteQueries: options.includeInfiniteQueries !== false,
-      includeOptimisticUpdates: options.includeOptimisticUpdates !== false,
-      includeMutationHelpers: options.includeMutationHelpers ?? true,
-      authenticationRequired: options.authenticationRequired ?? true,
-      errorHandling: options.errorHandling || "throw",
-      configPath: options.configPath || "./hooks.config.json",
-      enableConfidenceScoring: options.enableConfidenceScoring ?? true
-    };
-    this.configManager = new HookConfigManager(this.options.configPath);
-    this.confidenceScorer = new ConfidenceScorer();
-    this.bulkHookGenerator = new BulkHookGenerator();
-  }
-  /**
-   * Detect resource operations from endpoints
-   */
-  detectResourceOperations(endpoints) {
-    const resourceMap = /* @__PURE__ */ new Map();
-    endpoints.forEach((endpoint) => {
-      const resourceName = this.extractResourceName(endpoint.path);
-      if (!resourceName)
-        return;
-      const config = resourceMap.get(resourceName) || this.createDefaultConfig(resourceName);
-      const requestBody = endpoint.requestBody;
-      if (isBulkOperation(endpoint.path, endpoint.method, requestBody)) {
-        const bulkType = detectBulkOperationType(endpoint.path, endpoint.method);
-        switch (bulkType) {
-          case "delete":
-            config.operations.bulkDelete = {
-              path: endpoint.path,
-              method: endpoint.method
-            };
-            break;
-          case "update":
-            config.operations.bulkUpdate = {
-              path: endpoint.path,
-              method: endpoint.method
-            };
-            break;
-          case "create":
-            config.operations.bulkCreate = {
-              path: endpoint.path,
-              method: endpoint.method
-            };
-            break;
-          case "mixed":
-          default:
-            if (!config.operations.customBulk) {
-              config.operations.customBulk = [];
-            }
-            config.operations.customBulk.push({
-              name: this.getOperationName(endpoint),
-              path: endpoint.path,
-              method: endpoint.method,
-              operationType: bulkType || "mixed"
-            });
-            break;
-        }
-      } else {
-        switch (endpoint.method.toLowerCase()) {
-          case "get":
-            if (endpoint.path.includes("{")) {
-            } else {
-              config.operations.list = { path: endpoint.path, method: endpoint.method };
-            }
-            break;
-          case "post":
-            config.operations.create = { path: endpoint.path, method: endpoint.method };
-            break;
-          case "put":
-          case "patch":
-            config.operations.update = { path: endpoint.path, method: endpoint.method };
-            break;
-          case "delete":
-            config.operations.delete = { path: endpoint.path, method: endpoint.method };
-            break;
-        }
-      }
-      resourceMap.set(resourceName, config);
-    });
-    return resourceMap;
-  }
-  /**
-   * Extract resource name from path
-   */
-  extractResourceName(path) {
-    const cleanPath = path.replace(/^\/api\/v\d+\//, "/");
-    const segments = cleanPath.split("/").filter(Boolean);
-    for (const segment of segments) {
-      if (!segment.startsWith("{")) {
-        return segment.replace(/-/g, "_");
-      }
-    }
-    return null;
-  }
-  /**
-   * Create default API config for a resource
-   */
-  createDefaultConfig(resourceName) {
-    return {
-      baseURL: "",
-      resourceName,
-      operations: {}
-    };
-  }
-  async generate(parsedAPI) {
-    const endpoints = parsedAPI.endpoints;
-    await this.configManager.load();
-    this.resourceConfigs = this.detectResourceOperations(endpoints);
-    this.scoredNames = [];
-    const result = {
-      queries: this.generateQueryHooks(endpoints),
-      mutations: this.generateMutationHooks(endpoints),
-      keys: this.generateQueryKeys(endpoints),
-      types: this.generateHookTypes(endpoints),
-      index: this.generateIndexFile(),
-      report: void 0
-    };
-    if (this.options.enableConfidenceScoring && this.scoredNames.length > 0) {
-      console.log(`Generated ${this.scoredNames.length} scored hook names`);
-      result.report = this.confidenceScorer.generateReport(this.scoredNames);
-      const stats = {
-        totalGenerated: this.scoredNames.length,
-        highConfidence: this.scoredNames.filter((s) => s.confidence === "high").length,
-        mediumConfidence: this.scoredNames.filter((s) => s.confidence === "medium").length,
-        lowConfidence: this.scoredNames.filter((s) => s.confidence === "low").length,
-        humanReviewed: this.configManager.getReviewedNames().length
-      };
-      this.configManager.updateStatistics(stats);
-      await this.configManager.save();
-    }
-    return result;
-  }
-  generateQueryHooks(endpoints) {
-    const hooks = [];
-    hooks.push(this.generateFileHeader("Query Hooks"));
-    hooks.push("");
-    hooks.push("import { useQuery, useInfiniteQuery, type UseQueryOptions, type UseInfiniteQueryOptions } from '@tanstack/react-query'");
-    hooks.push("import { apiClient } from '../client'");
-    hooks.push("import { queryKeys } from './keys'");
-    hooks.push("import * as Types from './types'");
-    hooks.push("");
-    const queryEndpoints = endpoints.filter((endpoint) => endpoint.method === "get");
-    const generatedHooks = /* @__PURE__ */ new Map();
-    for (const endpoint of queryEndpoints) {
-      let hookName = this.generateQueryHookName(endpoint);
-      if (generatedHooks.has(hookName)) {
-        const existingEndpoint = generatedHooks.get(hookName);
-        const existingIsSimpler = existingEndpoint.path.split("/").filter((s) => !s.startsWith("{")).length < endpoint.path.split("/").filter((s) => !s.startsWith("{")).length;
-        if (existingIsSimpler) {
-          const suffix = endpoint.path.includes("/{subcategory_id}") ? "Single" : "List";
-          hookName = `${hookName}${suffix}`;
-        } else {
-          const existingSuffix = existingEndpoint.path.includes("/{subcategory_id}") ? "Single" : "List";
-          const existingHookName = hookName;
-          const newExistingHookName = `${existingHookName}${existingSuffix}`;
-          for (let i = hooks.length - 1; i >= 0; i--) {
-            if (hooks[i].includes(`function ${existingHookName}(`)) {
-              hooks[i] = hooks[i].replace(`function ${existingHookName}(`, `function ${newExistingHookName}(`);
-              if (i > 0 && hooks[i - 1].includes(`${existingHookName}`)) {
-                hooks[i - 1] = hooks[i - 1].replace(existingHookName, newExistingHookName);
-              }
-              break;
-            }
-          }
-          generatedHooks.delete(existingHookName);
-          generatedHooks.set(newExistingHookName, existingEndpoint);
-        }
-      }
-      generatedHooks.set(hookName, endpoint);
-      const hook = this.generateQueryHook(endpoint, hookName);
-      hooks.push(hook);
-      hooks.push("");
-      if (this.options.includeInfiniteQueries && this.isListEndpoint(endpoint)) {
-        const infiniteHook = this.generateInfiniteQueryHook(endpoint, hookName);
-        hooks.push(infiniteHook);
-        hooks.push("");
-      }
-    }
-    return hooks.join("\n");
-  }
-  generateQueryHook(endpoint, hookName) {
-    const operationName = this.getOperationName(endpoint);
-    const hasParams = this.hasRequiredParams(endpoint);
-    const lines = [];
-    lines.push("/**");
-    if (endpoint.summary) {
-      lines.push(` * ${endpoint.summary}`);
-    }
-    if (endpoint.description) {
-      lines.push(` * ${endpoint.description}`);
-    }
-    lines.push(` * @param ${hasParams ? "params" : "options"} ${hasParams ? "Request parameters" : "Query options"}`);
-    lines.push(" */");
-    const paramType = hasParams ? this.generateParamType(endpoint) : "";
-    const params = hasParams ? `params: ${paramType}, options?: UseQueryOptions<any, any, any>` : "options?: UseQueryOptions<any, any, any>";
-    lines.push(`export function ${hookName}(${params}) {`);
-    const queryKeyName = hookName.replace(/^use/, "");
-    const queryKeyNameCamelCase = queryKeyName.charAt(0).toLowerCase() + queryKeyName.slice(1);
-    const queryKeyCall = hasParams ? `queryKeys.${queryKeyNameCamelCase}(params)` : `queryKeys.${queryKeyNameCamelCase}()`;
-    const apiCall = hasParams ? `() => apiClient.${this.camelCase(operationName)}(params)` : `() => apiClient.${this.camelCase(operationName)}()`;
-    lines.push("  return useQuery({");
-    lines.push(`    queryKey: ${queryKeyCall},`);
-    lines.push(`    queryFn: ${apiCall},`);
-    lines.push("    ...options");
-    lines.push("  })");
-    lines.push("}");
-    return lines.join("\n");
-  }
-  generateInfiniteQueryHook(endpoint, baseHookName) {
-    const hookName = baseHookName.replace("use", "useInfinite");
-    const operationName = this.getOperationName(endpoint);
-    const lines = [];
-    lines.push("/**");
-    lines.push(` * Infinite query version of ${baseHookName}`);
-    lines.push(" */");
-    const paramType = this.generateParamType(endpoint);
-    const queryKeyName = baseHookName.replace(/^use/, "");
-    const queryKeyNameCamelCase = queryKeyName.charAt(0).toLowerCase() + queryKeyName.slice(1);
-    lines.push(`export function ${hookName}(params: ${paramType}, options?: UseInfiniteQueryOptions<any, any, any, any, any>) {`);
-    lines.push("  return useInfiniteQuery({");
-    lines.push(`    queryKey: [...queryKeys.${queryKeyNameCamelCase}(), params],`);
-    lines.push(`    queryFn: ({ pageParam = 1 }) => apiClient.${this.camelCase(operationName)}({ ...params, page: pageParam }),`);
-    lines.push("    getNextPageParam: (lastPage, allPages) => {");
-    lines.push("      // Implement pagination logic based on your API response structure");
-    lines.push("      return lastPage?.hasNextPage ? allPages.length + 1 : undefined");
-    lines.push("    },");
-    lines.push("    initialPageParam: 1,");
-    lines.push("    ...options");
-    lines.push("  })");
-    lines.push("}");
-    return lines.join("\n");
-  }
-  generateMutationHooks(endpoints) {
-    const hooks = [];
-    hooks.push(this.generateFileHeader("Mutation Hooks"));
-    hooks.push("");
-    hooks.push("import { useMutation, useQueryClient, type UseMutationOptions } from '@tanstack/react-query'");
-    hooks.push("import { apiClient } from '../client'");
-    hooks.push("import { queryKeys } from './keys'");
-    hooks.push("import * as Types from './types'");
-    hooks.push("import type { BulkOperationRequest, BulkOperationResponse, BulkOperationProgress, BulkMutationOptions } from '../bulk-types'");
-    hooks.push("");
-    const mutationEndpoints = endpoints.filter((endpoint) => endpoint.method !== "get");
-    const generatedHooks = /* @__PURE__ */ new Map();
-    for (const endpoint of mutationEndpoints) {
-      const requestBody = endpoint.requestBody;
-      const isBulk = isBulkOperation(endpoint.path, endpoint.method, requestBody);
-      let hookName = this.generateMutationHookName(endpoint);
-      if (generatedHooks.has(hookName)) {
-        const existingEndpoint = generatedHooks.get(hookName);
-        const methodSuffix = endpoint.method.charAt(0).toUpperCase() + endpoint.method.slice(1);
-        hookName = `${hookName}${methodSuffix}`;
-      }
-      generatedHooks.set(hookName, endpoint);
-      const hook = isBulk ? this.bulkHookGenerator.generateBulkMutationHook(endpoint, hookName, this.getOperationName(endpoint)) : this.generateMutationHook(endpoint, hookName);
-      hooks.push(hook);
-      hooks.push("");
-    }
-    return hooks.join("\n");
-  }
-  generateMutationHook(endpoint, hookName) {
-    const operationName = this.getOperationName(endpoint);
-    const lines = [];
-    lines.push("/**");
-    if (endpoint.summary) {
-      lines.push(` * ${endpoint.summary}`);
-    }
-    if (endpoint.description) {
-      lines.push(` * ${endpoint.description}`);
-    }
-    lines.push(" */");
-    const mutationType = this.generateMutationType(endpoint);
-    lines.push(`export function ${hookName}(options?: UseMutationOptions<any, any, ${mutationType}>) {`);
-    lines.push("  const queryClient = useQueryClient()");
-    lines.push("");
-    lines.push("  return useMutation({");
-    const hasParams = this.hasRequiredParams(endpoint);
-    if (hasParams) {
-      lines.push(`    mutationFn: ({ pathParams, ...data }) => apiClient.${this.camelCase(operationName)}(pathParams, data),`);
-    } else {
-      lines.push(`    mutationFn: (data) => apiClient.${this.camelCase(operationName)}(data),`);
-    }
-    if (this.options.includeOptimisticUpdates) {
-      lines.push(this.generateOptimisticUpdate(endpoint));
-    }
-    lines.push(this.generateCacheInvalidation(endpoint));
-    lines.push("    ...options");
-    lines.push("  })");
-    lines.push("}");
-    return lines.join("\n");
-  }
-  generateOptimisticUpdate(endpoint) {
-    const method = endpoint.method.toLowerCase();
-    const resource = endpoint.tags?.[0] || "default";
-    const hasPathParams = endpoint.parameters.some((p) => p.in === "path");
-    switch (method) {
-      case "post":
-        return `    onMutate: async (data: any) => {
-      // Cancel outgoing refetches
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      // Snapshot previous value
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Optimistically update cache
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return [...old, data]
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, data: any, context: any) => {
-      // Rollback on error
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      case "put":
-      case "patch":
-        if (hasPathParams) {
-          return `    onMutate: async (data: any) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Update specific item in cache
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          return old.map((item: any) => 
-            item.id === data.pathParams?.id || item.id === data.pathParams?.${resource.slice(0, -1)}_id 
-              ? { ...item, ...data } 
-              : item
-          )
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, data: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-        }
-        return `    onMutate: async (data: any) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Update cache with new data
-      queryClient.setQueryData(queryKeys.${resource}(), data)
-      
-      return { previousData }
-    },
-    onError: (err: any, data: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      case "delete":
-        return `    onMutate: async (data: any) => {
-      await queryClient.cancelQueries({ queryKey: queryKeys.${resource}() })
-      
-      const previousData = queryClient.getQueryData(queryKeys.${resource}())
-      
-      // Remove item from cache
-      queryClient.setQueryData(queryKeys.${resource}(), (old: any) => {
-        if (Array.isArray(old)) {
-          const idToDelete = data.pathParams?.id || data.pathParams?.${resource.slice(0, -1)}_id || data
-          return old.filter((item: any) => item.id !== idToDelete)
-        }
-        return old
-      })
-      
-      return { previousData }
-    },
-    onError: (err: any, data: any, context: any) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKeys.${resource}(), context.previousData)
-      }
-    },`;
-      default:
-        return "";
-    }
-  }
-  generateCacheInvalidation(endpoint) {
-    const relatedTags = this.getRelatedQueryTags(endpoint);
-    return `    onSettled: () => {
-      // Invalidate related queries
-      ${relatedTags.map((tag) => `queryClient.invalidateQueries({ queryKey: queryKeys.${tag}() })`).join("\n      ")}
-    },`;
-  }
-  generateQueryKeys(endpoints) {
-    const keys = [];
-    keys.push(this.generateFileHeader("Query Keys"));
-    keys.push("");
-    keys.push("/**");
-    keys.push(" * Centralized query key factory");
-    keys.push(" * Ensures consistent cache key generation across the application");
-    keys.push(" */");
-    keys.push("");
-    keys.push("export const queryKeys = {");
-    keys.push(`  all: ['${this.options.queryKeyPrefix}'] as const,`);
-    keys.push("");
-    const groupedEndpoints = this.groupEndpointsByResource(endpoints);
-    for (const [resource, resourceEndpoints] of Object.entries(groupedEndpoints)) {
-      keys.push(`  // ${resource} keys`);
-      keys.push(`  ${resource}: () => [...queryKeys.all, '${resource}'] as const,`);
-      const generatedKeys = /* @__PURE__ */ new Map();
-      for (const endpoint of resourceEndpoints) {
-        if (endpoint.method !== "get")
-          continue;
-        const operationName = this.getOperationName(endpoint);
-        let keyName = this.camelCase(operationName.replace(/^get/, ""));
-        if (generatedKeys.has(keyName)) {
-          const existingEndpoint = generatedKeys.get(keyName);
-          const existingIsSimpler = existingEndpoint.path.split("/").filter((s) => !s.startsWith("{")).length < endpoint.path.split("/").filter((s) => !s.startsWith("{")).length;
-          if (existingIsSimpler) {
-            const suffix = endpoint.path.includes("/{subcategory_id}") ? "Single" : "List";
-            keyName = `${keyName}${suffix}`;
-          } else {
-            const existingSuffix = existingEndpoint.path.includes("/{subcategory_id}") ? "Single" : "List";
-            const existingKeyName = keyName;
-            const newExistingKeyName = `${existingKeyName}${existingSuffix}`;
-            for (let i = keys.length - 1; i >= 0; i--) {
-              if (keys[i].includes(`${existingKeyName}:`)) {
-                keys[i] = keys[i].replace(`${existingKeyName}:`, `${newExistingKeyName}:`).replace(`'${existingKeyName}'`, `'${newExistingKeyName}'`);
-                break;
-              }
-            }
-            generatedKeys.delete(existingKeyName);
-            generatedKeys.set(newExistingKeyName, existingEndpoint);
-          }
-        }
-        generatedKeys.set(keyName, endpoint);
-        if (this.hasRequiredParams(endpoint)) {
-          keys.push(`  ${keyName}: (params: any) => [...queryKeys.${resource}(), '${keyName}', params] as const,`);
-        } else {
-          keys.push(`  ${keyName}: () => [...queryKeys.${resource}(), '${keyName}'] as const,`);
-        }
-      }
-      keys.push("");
-    }
-    keys.push("}");
-    return keys.join("\n");
-  }
-  generateHookTypes(endpoints) {
-    const types = [];
-    types.push(this.generateFileHeader("Hook Types"));
-    types.push("");
-    types.push("// Re-export bulk operation types for convenience");
-    types.push("export type { BulkOperationRequest, BulkOperationResponse, BulkOperationProgress, BulkMutationOptions } from '../bulk-types'");
-    types.push("");
-    const generatedTypes = /* @__PURE__ */ new Set();
-    for (const endpoint of endpoints) {
-      const operationName = this.getOperationName(endpoint);
-      if (this.hasRequiredParams(endpoint)) {
-        const typeName = `${this.capitalize(operationName)}Params`;
-        if (!generatedTypes.has(typeName)) {
-          generatedTypes.add(typeName);
-          const paramType = this.generateParamType(endpoint);
-          types.push(`export interface ${typeName} ${paramType}`);
-          types.push("");
-        }
-      }
-      if (endpoint.method !== "get") {
-        const typeName = `${this.capitalize(operationName)}Data`;
-        if (!generatedTypes.has(typeName)) {
-          generatedTypes.add(typeName);
-          const mutationType = this.generateMutationType(endpoint);
-          types.push(`export interface ${typeName} ${mutationType}`);
-          types.push("");
-        }
-      }
-    }
-    return types.join("\n");
-  }
-  generateIndexFile() {
-    const exports2 = [];
-    exports2.push(this.generateFileHeader("Generated React Hooks"));
-    exports2.push("");
-    exports2.push("// Query hooks");
-    exports2.push("export * from './queries'");
-    exports2.push("");
-    exports2.push("// Mutation hooks");
-    exports2.push("export * from './mutations'");
-    exports2.push("");
-    exports2.push("// Query keys");
-    exports2.push("export { queryKeys } from './keys'");
-    exports2.push("");
-    exports2.push("// Hook types");
-    exports2.push("export * from './types'");
-    return exports2.join("\n");
-  }
-  generateFileHeader(title) {
-    return `/**
- * ${title}
- * 
- * Auto-generated React hooks from OpenAPI specification
- * Do not edit manually - regenerate using the hook generator
- */`;
-  }
-  generateQueryHookName(endpoint) {
-    const operationName = this.getOperationName(endpoint);
-    return `use${this.capitalize(operationName)}`;
-  }
-  generateMutationHookName(endpoint) {
-    const operationName = this.getOperationName(endpoint);
-    const resourceName = this.extractResourceName(endpoint.path);
-    if (resourceName) {
-      const bulkHookName = this.bulkHookGenerator.generateBulkMutationHookName(endpoint, resourceName);
-      if (bulkHookName) {
-        return bulkHookName;
-      }
-    }
-    return `use${this.capitalize(operationName)}`;
-  }
-  getOperationName(endpoint) {
-    if (endpoint.operationId) {
-      const override = this.configManager.getOverride(endpoint.operationId);
-      if (override) {
-        return override;
-      }
-    }
-    let operationName;
-    if (endpoint.operationId) {
-      operationName = this.cleanOperationId(endpoint.operationId, endpoint);
-    } else {
-      operationName = this.generateCleanName(endpoint);
-    }
-    const patterns = this.configManager.getPatterns();
-    if (patterns.deduplicateSegments) {
-      operationName = this.removeDuplicateSegments(operationName);
-    }
-    if (this.options.enableConfidenceScoring && endpoint.operationId) {
-      const hookName = endpoint.method === "get" ? `use${this.capitalize(operationName)}` : `use${this.capitalize(this.getMethodPrefix(endpoint.method))}${this.capitalize(operationName)}`;
-      const scored = this.confidenceScorer.scoreHookName(hookName, endpoint.operationId, endpoint.path, endpoint.method);
-      if (scored.confidence === "low") {
-        console.log(`Low confidence hook: ${hookName} (score: ${scored.score})`);
-      }
-      this.scoredNames.push(scored);
-      if (scored.confidence === "low" && scored.suggestions.length > 0) {
-        const suggestion = scored.suggestions[0];
-        const prefix = `use${this.capitalize(this.getMethodPrefix(endpoint.method))}`;
-        if (suggestion.startsWith(prefix)) {
-          operationName = this.camelCase(suggestion.substring(prefix.length));
-        } else if (suggestion.startsWith("use")) {
-          operationName = this.camelCase(suggestion.substring(3));
-        }
-      }
-    }
-    return operationName;
-  }
-  cleanOperationId(operationId, endpoint) {
-    const parsed = this.parseOperationId(operationId, endpoint);
-    return this.generateNameFromParsed(parsed, endpoint);
-  }
-  /**
-   * Parse operation ID into structured components
-   */
-  parseOperationId(operationId, endpoint) {
-    const cleaned = operationId.replace(/_api_v\d+_/g, "_").replace(/_(get|post|put|patch|delete)$/i, "");
-    const parts = cleaned.split("_").filter(Boolean);
-    const prefix = this.extractPrefix(parts, { ...endpoint, operationId });
-    const resources = this.extractResourcesFromPath(endpoint.path);
-    const segments = endpoint.path.split("/");
-    const lastSegment = segments[segments.length - 1];
-    const isCustomAction = !lastSegment.startsWith("{") && segments[segments.length - 2]?.startsWith("{");
-    return {
-      action: prefix?.action || "",
-      resource: resources.primary || "",
-      subResource: resources.sub?.[0] || "",
-      method: endpoint.method,
-      isCustomAction,
-      customActionName: isCustomAction ? lastSegment.replace(/-/g, "_") : void 0,
-      originalId: operationId,
-      prefix: prefix?.fullPrefix || "",
-      resources
-    };
-  }
-  /**
-   * Extract meaningful prefix from operation ID parts
-   */
-  extractPrefix(parts, endpoint) {
-    if (parts.length === 0)
-      return null;
-    const originalId = endpoint.operationId || "";
-    const knownActions = [
-      "login",
-      "logout",
-      "register",
-      "signup",
-      "signin",
-      "assign",
-      "reassign",
-      "create",
-      "update",
-      "delete",
-      "get",
-      "list",
-      "health",
-      "status",
-      "verify",
-      "validate"
-    ];
-    const firstPart = parts[0].toLowerCase();
-    if (knownActions.includes(firstPart)) {
-      if (firstPart === "get" && originalId.startsWith("get_")) {
-        const match = originalId.match(/^get_(.+?)_api_v\d+/);
-        if (match) {
-          const compoundName = match[1];
-          if (compoundName === "health_status" || compoundName === "current_user_info") {
-            return {
-              action: firstPart,
-              fullPrefix: `${firstPart}_${compoundName}`
-            };
-          }
-        }
-      }
-      if (parts.length > 1 && ["assign", "reassign"].includes(firstPart)) {
-        if (firstPart === "reassign" && parts[1] === "transaction" && parts[2] === "budget") {
-          return {
-            action: "reassign",
-            fullPrefix: "reassign_budget"
-          };
-        }
-        return {
-          action: firstPart,
-          fullPrefix: `${parts[0]}_${parts[1]}`
-        };
-      }
-      return {
-        action: firstPart,
-        fullPrefix: parts[0]
-      };
-    }
-    return null;
-  }
-  /**
-   * Extract resources from API path
-   */
-  extractResourcesFromPath(path) {
-    const cleanPath = path.replace(/^\/api\/v\d+\//, "/");
-    const segments = cleanPath.split("/").filter(Boolean);
-    const resources = [];
-    let lastHasParam = false;
-    for (let i = 0; i < segments.length; i++) {
-      if (!segments[i].startsWith("{")) {
-        resources.push(segments[i].replace(/-/g, "_"));
-      } else if (i === segments.length - 1) {
-        lastHasParam = true;
-      }
-    }
-    return {
-      primary: resources[0] || "",
-      sub: resources.slice(1),
-      lastHasParam
-    };
-  }
-  /**
-   * Generate clean hook name from parsed components
-   */
-  generateNameFromParsed(parsed, endpoint) {
-    if (parsed.prefix === "login")
-      return "login";
-    if (parsed.prefix === "logout")
-      return "logout";
-    if (parsed.prefix && parsed.prefix.startsWith("get_") && parsed.prefix.includes("_")) {
-      const withoutGet = parsed.prefix.substring(4);
-      if (withoutGet === "health_status" || withoutGet === "current_user_info") {
-        return withoutGet;
-      }
-    }
-    if (parsed.prefix && this.isMeaningfulPrefix(parsed.prefix, parsed.resources)) {
-      return this.formatWithPrefix(parsed);
-    }
-    return this.formatStandardOperation(parsed, endpoint);
-  }
-  /**
-   * Check if prefix adds meaningful context
-   */
-  isMeaningfulPrefix(prefix, resources) {
-    const action = prefix.split("_")[0];
-    if (prefix === resources.primary)
-      return false;
-    if (prefix === `get_${resources.primary}`)
-      return false;
-    if (prefix === `list_${resources.primary}`)
-      return false;
-    return ["assign", "reassign", "verify", "validate", "sync", "refresh"].includes(action);
-  }
-  /**
-   * Format name with meaningful prefix
-   */
-  formatWithPrefix(parsed) {
-    const { prefix, resources, originalId, isCustomAction, customActionName } = parsed;
-    const prefixParts = prefix.split("_");
-    const action = prefixParts[0];
-    const subject = prefixParts.slice(1).join("_");
-    if (isCustomAction && customActionName) {
-      if (action === "reassign" && subject === "budget") {
-        return `reassign_${this.singularize(resources.primary)}_budget`;
-      }
-    }
-    if (subject && resources.sub.length > 0) {
-      const subResource = resources.sub[0];
-      if (subject === subResource || subject === this.pluralize(subResource)) {
-        return `${action}_${this.singularize(resources.primary)}_${subResource}`;
-      }
-    }
-    if (resources.sub.length > 0 && !isCustomAction) {
-      return `${action}_${this.singularize(resources.primary)}_${resources.sub[0]}`;
-    }
-    return `${action}_${this.singularize(resources.primary)}`;
-  }
-  /**
-   * Format standard REST operation
-   */
-  formatStandardOperation(parsed, endpoint) {
-    const { resources, method } = parsed;
-    const hasParams = endpoint.path.includes("{");
-    const isListOperation = method === "get" && !hasParams;
-    if (resources.sub.length > 0) {
-      const primary = this.singularize(resources.primary);
-      const sub = resources.sub[0];
-      switch (method) {
-        case "get":
-          return isListOperation ? `${primary}_${this.pluralize(sub)}` : `${primary}_${sub}`;
-        case "post":
-          return `create_${primary}_${this.singularize(sub)}`;
-        case "put":
-        case "patch":
-          return `set_${primary}_${sub}`;
-        case "delete":
-          return `remove_${primary}_${sub}`;
-      }
-    }
-    switch (method) {
-      case "get":
-        return isListOperation ? this.pluralize(resources.primary) : this.singularize(resources.primary);
-      case "post":
-        return `create_${this.singularize(resources.primary)}`;
-      case "put":
-      case "patch":
-        return `update_${this.singularize(resources.primary)}`;
-      case "delete":
-        return `delete_${this.singularize(resources.primary)}`;
-      default:
-        return this.singularize(resources.primary);
-    }
-  }
-  generateCleanName(endpoint) {
-    const pathParts = endpoint.path.split("/").filter((part) => part && !part.startsWith("{"));
-    if (pathParts.length === 0)
-      return endpoint.method;
-    const resource = pathParts[pathParts.length - 1];
-    const cleanResource = resource.replace(/-/g, "_");
-    const segments = endpoint.path.split("/");
-    const lastSegment = segments[segments.length - 1];
-    const hasCustomAction = !lastSegment.startsWith("{") && segments[segments.length - 2]?.startsWith("{");
-    if (hasCustomAction) {
-      const mainResource = pathParts[pathParts.length - 2] || pathParts[pathParts.length - 1];
-      const action = lastSegment.replace(/-/g, "_");
-      return `${mainResource}_${action}`;
-    }
-    if (pathParts.length > 2 && segments.some((s) => s.startsWith("{"))) {
-      return cleanResource;
-    }
-    switch (endpoint.method) {
-      case "get":
-        const isList = !endpoint.path.includes("{");
-        if (isList && !cleanResource.endsWith("s") && !cleanResource.endsWith("ies")) {
-          return this.pluralize(cleanResource);
-        }
-        return cleanResource;
-      case "post":
-        return `create_${cleanResource}`;
-      case "put":
-      case "patch":
-        return `update_${cleanResource}`;
-      case "delete":
-        return `delete_${cleanResource}`;
-      default:
-        return `${endpoint.method}_${cleanResource}`;
-    }
-  }
-  pluralize(word) {
-    if (word.endsWith("s") && !word.endsWith("ss") && !word.endsWith("us") && !word.endsWith("is")) {
-      return word;
-    }
-    if (word.endsWith("y") && !["ay", "ey", "iy", "oy", "uy"].includes(word.slice(-2))) {
-      return word.slice(0, -1) + "ies";
-    }
-    if (word.endsWith("ss") || word.endsWith("x") || word.endsWith("ch") || word.endsWith("sh")) {
-      return word + "es";
-    }
-    if (word.endsWith("us")) {
-      return word.slice(0, -2) + "i";
-    }
-    if (word.endsWith("is")) {
-      return word.slice(0, -2) + "es";
-    }
-    return word + "s";
-  }
-  singularize(word) {
-    if (word.endsWith("ies")) {
-      return word.slice(0, -3) + "y";
-    }
-    if (word.endsWith("ses") || word.endsWith("xes") || word.endsWith("ches") || word.endsWith("shes")) {
-      return word.slice(0, -2);
-    }
-    if (word.endsWith("s") && !word.endsWith("ss")) {
-      return word.slice(0, -1);
-    }
-    return word;
-  }
-  hasRequiredParams(endpoint) {
-    return endpoint.parameters.some((p) => p.required) || endpoint.parameters.some((p) => p.in === "path");
-  }
-  generateParamType(endpoint) {
-    const pathParams = endpoint.parameters.filter((p) => p.in === "path");
-    const queryParams = endpoint.parameters.filter((p) => p.in === "query");
-    const properties = [];
-    pathParams.forEach((param) => {
-      properties.push(`${param.name}: ${this.getParameterType(param)}`);
-    });
-    queryParams.forEach((param) => {
-      const optional = param.required ? "" : "?";
-      properties.push(`${param.name}${optional}: ${this.getParameterType(param)}`);
-    });
-    return `{ ${properties.join("; ")} }`;
-  }
-  generateMutationType(endpoint) {
-    const hasPathParams = endpoint.parameters.some((p) => p.in === "path");
-    if (hasPathParams) {
-      const pathType = this.generateParamType(endpoint);
-      return `{ pathParams: ${pathType}; [key: string]: any }`;
-    }
-    return "{ [key: string]: any }";
-  }
-  getParameterType(param) {
-    switch (param.schema.type) {
-      case "string":
-        return "string";
-      case "number":
-      case "integer":
-        return "number";
-      case "boolean":
-        return "boolean";
-      default:
-        return "any";
-    }
-  }
-  isListEndpoint(endpoint) {
-    if (endpoint.method.toLowerCase() !== "get")
-      return false;
-    if (endpoint.path.includes("{"))
-      return false;
-    if (endpoint.responses?.["200"]?.schema?.type === "array")
-      return true;
-    const description = `${endpoint.summary || ""} ${endpoint.description || ""}`.toLowerCase();
-    return description.includes("list") || description.includes("get all") || description.includes("fetch all");
-  }
-  groupEndpointsByResource(endpoints) {
-    const groups = {};
-    for (const endpoint of endpoints) {
-      const resource = endpoint.tags?.[0] || "default";
-      if (!groups[resource]) {
-        groups[resource] = [];
-      }
-      groups[resource].push(endpoint);
-    }
-    return groups;
-  }
-  getRelatedQueryTags(endpoint) {
-    const resource = endpoint.tags?.[0] || "default";
-    return [resource, "all"];
-  }
-  camelCase(str) {
-    return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^./, (char) => char.toLowerCase());
-  }
-  capitalize(str) {
-    return str.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-  }
-  getMethodPrefix(method) {
-    const prefixes = {
-      post: "create",
-      put: "update",
-      patch: "update",
-      delete: "delete"
-    };
-    return prefixes[method.toLowerCase()] || method.toLowerCase();
-  }
-  removeDuplicateSegments(operationName) {
-    const parts = operationName.split("_");
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const part of parts) {
-      const lower = part.toLowerCase();
-      if (!seen.has(lower)) {
-        seen.add(lower);
-        result.push(part);
-      }
-    }
-    return result.join("_");
-  }
-};
-async function generateHooks(parsedAPI, options) {
-  const generator = new ReactHookGenerator(options);
-  return generator.generate(parsedAPI);
-}
-
-// cli/commands/generate-hooks.ts
-async function generateHooksCommand(source, options) {
-  try {
-    console.log("\u{1F680} Pattern-Stack Hook Generator");
-    console.log("================================");
-    console.log();
-    console.log("\u{1F4E5} Loading OpenAPI specification...");
-    const spec = await loadOpenAPISpec(source);
-    console.log(`\u2705 Loaded: ${spec.info.title} v${spec.info.version}`);
-    console.log("\u{1F50D} Parsing specification...");
-    const parsed = await parseOpenAPI(spec);
-    console.log(`\u2705 Found ${parsed.endpoints.length} endpoints, ${parsed.schemas.length} schemas`);
-    console.log("\u{1F3D7}\uFE0F  Generating TypeScript types...");
-    const types = generateTypes(parsed, {
-      prefix: options.prefix,
-      includeJSDoc: true,
-      includeExamples: true
-    });
-    console.log("\u{1F527} Generating API client...");
-    const client = generateAPIClient(parsed, {
-      clientType: options.client,
-      includeAuth: true,
-      authType: options.auth,
-      includeInterceptors: true
-    });
-    console.log("\u269B\uFE0F  Generating React hooks...");
-    const hooks = await generateHooks(parsed, {
-      includeInfiniteQueries: true,
-      includeOptimisticUpdates: true,
-      includeMutationHelpers: true,
-      enableConfidenceScoring: true
-    });
-    if (options.dryRun) {
-      console.log("\n\u{1F4CB} Dry run - files that would be generated:");
-      console.log("Types:");
-      console.log("  - schemas.ts");
-      console.log("  - endpoints.ts");
-      console.log("  - parameters.ts");
-      console.log("  - responses.ts");
-      console.log();
-      console.log("API Client:");
-      console.log("  - client.ts");
-      console.log("  - methods.ts");
-      console.log("  - types.ts");
-      console.log("  - config.ts");
-      console.log();
-      console.log("React Hooks:");
-      console.log("  - queries.ts");
-      console.log("  - mutations.ts");
-      console.log("  - keys.ts");
-      console.log("  - types.ts");
-      console.log();
-      console.log("Generated code preview:");
-      console.log("======================");
-      console.log();
-      console.log("Types (first 20 lines):");
-      console.log(types.schemas.split("\n").slice(0, 20).join("\n"));
-      console.log("\n...");
-      return;
-    }
-    console.log(`\u{1F4C1} Creating output directory: ${options.output}`);
-    await ensureDir(options.output);
-    await ensureDir((0, import_path3.join)(options.output, "types"));
-    await ensureDir((0, import_path3.join)(options.output, "client"));
-    await ensureDir((0, import_path3.join)(options.output, "hooks"));
-    console.log("\u{1F4BE} Writing type definitions...");
-    await writeFile((0, import_path3.join)(options.output, "types", "schemas.ts"), types.schemas);
-    await writeFile((0, import_path3.join)(options.output, "types", "endpoints.ts"), types.endpoints);
-    await writeFile((0, import_path3.join)(options.output, "types", "parameters.ts"), types.parameters);
-    await writeFile((0, import_path3.join)(options.output, "types", "responses.ts"), types.responses);
-    await writeFile((0, import_path3.join)(options.output, "types", "index.ts"), types.index);
-    console.log("\u{1F4BE} Writing API client...");
-    await writeFile((0, import_path3.join)(options.output, "client", "client.ts"), client.client);
-    await writeFile((0, import_path3.join)(options.output, "client", "methods.ts"), client.methods);
-    await writeFile((0, import_path3.join)(options.output, "client", "types.ts"), client.types);
-    await writeFile((0, import_path3.join)(options.output, "client", "config.ts"), client.config);
-    await writeFile((0, import_path3.join)(options.output, "client", "index.ts"), client.index);
-    console.log("\u{1F4BE} Writing React hooks...");
-    await writeFile((0, import_path3.join)(options.output, "hooks", "queries.ts"), hooks.queries);
-    await writeFile((0, import_path3.join)(options.output, "hooks", "mutations.ts"), hooks.mutations);
-    await writeFile((0, import_path3.join)(options.output, "hooks", "keys.ts"), hooks.keys);
-    await writeFile((0, import_path3.join)(options.output, "hooks", "types.ts"), hooks.types);
-    await writeFile((0, import_path3.join)(options.output, "hooks", "index.ts"), hooks.index);
-    if (hooks.report) {
-      await writeFile((0, import_path3.join)(options.output, "hooks", "confidence-report.md"), hooks.report);
-      console.log("\u{1F4CA} Generated confidence report");
-      const lowConfidenceCount = (hooks.report.match(/## Low Confidence Names/g) || []).length;
-      if (lowConfidenceCount > 0) {
-        console.log("\n\u26A0\uFE0F  Some hook names have low confidence and may need review.");
-        console.log("Run `npm run review:hooks` to interactively review and improve them.");
-      }
-    }
-    const mainIndex = `/**
- * Generated API Integration
- * 
- * Auto-generated from OpenAPI specification: ${spec.info.title}
- * Version: ${spec.info.version}
- * Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
- */
-
-export * from './types'
-export * from './client'
-export * from './hooks'
-
-// Quick start exports
-export { createAPIClient } from './client'
-export { queryKeys } from './hooks'`;
-    await writeFile((0, import_path3.join)(options.output, "index.ts"), mainIndex);
-    const usageExample = generateUsageExample(spec.info.title, options);
-    await writeFile((0, import_path3.join)(options.output, "example.ts"), usageExample);
-    console.log();
-    console.log("\u2705 Generation complete!");
-    console.log(`\u{1F4E6} Generated files in: ${options.output}`);
-    console.log();
-    console.log("\u{1F680} Quick start:");
-    console.log(`import { createAPIClient, useGetUsers } from './${options.output}'`);
-    console.log();
-    console.log("\u{1F4A1} See example.ts for detailed usage instructions");
-  } catch (error) {
-    console.error("\u274C Generation failed:");
-    console.error(error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-async function ensureDir(dir) {
-  try {
-    await import_fs3.promises.mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-}
-async function writeFile(path, content) {
-  await ensureDir((0, import_path3.dirname)(path));
-  await import_fs3.promises.writeFile(path, content, "utf8");
-}
-function generateUsageExample(apiTitle, options) {
-  return `/**
- * ${apiTitle} - Usage Example
- * 
- * This file demonstrates how to use the generated API integration
- */
-
-import React from 'react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { createAPIClient, useGetUsers, useCreateUser } from './'
-
-// 1. Set up the API client
-const apiClient = createAPIClient({
-  baseUrl: 'https://api.example.com/v1',
-  ${options.auth === "bearer" ? `getAuthToken: () => localStorage.getItem('authToken'),` : ""}
-  ${options.auth === "apiKey" ? `getApiKey: () => process.env.REACT_APP_API_KEY,
-  apiKeyHeader: 'X-API-Key',` : ""}
-  onError: (error) => {
-    console.error('API Error:', error)
-    // Handle global errors (show toast, redirect to login, etc.)
-  }
-})
-
-// 2. Set up React Query
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 5 * 60 * 1000, // 5 minutes
-      cacheTime: 10 * 60 * 1000, // 10 minutes
-    },
-  },
-})
-
-// 3. Wrap your app with providers
-function App() {
-  return (
-    <QueryClientProvider client={queryClient}>
-      <UserList />
-    </QueryClientProvider>
-  )
-}
-
-// 4. Use generated hooks in components
-function UserList() {
-  // Query hook with automatic loading, error, and data states
-  const { data: users, isLoading, error } = useGetUsers({
-    limit: 10
-  })
-
-  // Mutation hook with optimistic updates
-  const createUserMutation = useCreateUser({
-    onSuccess: () => {
-      console.log('User created successfully!')
-    },
-    onError: (error) => {
-      console.error('Failed to create user:', error)
-    }
-  })
-
-  const handleCreateUser = () => {
-    createUserMutation.mutate({
-      email: 'new@example.com',
-      name: 'New User'
-    })
-  }
-
-  if (isLoading) return <div>Loading users...</div>
-  if (error) return <div>Error: {error.message}</div>
-
-  return (
-    <div>
-      <h2>Users</h2>
-      <button 
-        onClick={handleCreateUser}
-        disabled={createUserMutation.isLoading}
-      >
-        {createUserMutation.isLoading ? 'Creating...' : 'Create User'}
-      </button>
-      
-      <ul>
-        {users?.map(user => (
-          <li key={user.id}>
-            {user.name} ({user.email})
-          </li>
-        ))}
-      </ul>
-    </div>
-  )
-}
-
-// 5. Advanced usage with infinite queries
-function InfiniteUserList() {
-  const {
-    data,
-    fetchNextPage,
-    hasNextPage,
-    isFetchingNextPage,
-  } = useInfiniteGetUsers({
-    limit: 20
-  })
-
-  return (
-    <div>
-      {data?.pages.map((page, i) => (
-        <React.Fragment key={i}>
-          {page.map(user => (
-            <div key={user.id}>{user.name}</div>
-          ))}
-        </React.Fragment>
-      ))}
-      
-      <button
-        onClick={() => fetchNextPage()}
-        disabled={!hasNextPage || isFetchingNextPage}
-      >
-        {isFetchingNextPage
-          ? 'Loading more...'
-          : hasNextPage
-          ? 'Load More'
-          : 'Nothing more to load'}
-      </button>
-    </div>
-  )
-}
-
-export default App`;
-}
-
-// cli/commands/scaffold.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
-async function scaffoldCommand(type, name, options) {
-  console.log(`\u{1F3D7}\uFE0F  Scaffolding ${type}: ${name}`);
-  switch (type) {
-    case "component":
-      await scaffoldComponent(name, options);
-      break;
-    case "feature":
-      await scaffoldFeature(name, options);
-      break;
-    case "template":
-      await scaffoldTemplate(name, options);
-      break;
-    default:
-      console.error(`\u274C Unknown scaffold type: ${type}`);
-      console.log("Available types: component, feature, template");
-      process.exit(1);
-  }
-}
-async function scaffoldComponent(name, options) {
-  const outputDir = options.output || `./src/atoms/composed/${name}`;
-  const componentContent = `/**
- * ${name} Component
- * 
- * Generated by Pattern-Stack CLI
- */
-
-import React from 'react'
-import { cn } from '../../utils/utils'
-
-export interface ${name}Props {
-  className?: string
-  children?: React.ReactNode
-}
-
-export function ${name}({ className, children, ...props }: ${name}Props) {
-  return (
-    <div className={cn("", className)} {...props}>
-      {children}
-    </div>
-  )
-}
-
-${name}.displayName = "${name}"`;
-  const indexContent = `export { ${name} } from './${name}'
-export type { ${name}Props } from './${name}'`;
-  const testContent = `/**
- * ${name} Component Tests
- */
-
-import { render, screen } from '@testing-library/react'
-import { ${name} } from './${name}'
-
-describe('${name}', () => {
-  it('renders children', () => {
-    render(<${name}>Test content</${name}>)
-    expect(screen.getByText('Test content')).toBeInTheDocument()
-  })
-
-  it('applies custom className', () => {
-    const { container } = render(<${name} className="custom-class" />)
-    expect(container.firstChild).toHaveClass('custom-class')
-  })
-})`;
-  await ensureDir2(outputDir);
-  await writeFile2((0, import_path4.join)(outputDir, `${name}.tsx`), componentContent);
-  await writeFile2((0, import_path4.join)(outputDir, "index.ts"), indexContent);
-  await writeFile2((0, import_path4.join)(outputDir, `${name}.test.tsx`), testContent);
-  console.log(`\u2705 Component scaffolded: ${outputDir}`);
-}
-async function scaffoldFeature(name, options) {
-  const outputDir = options.output || `./src/features/${name.toLowerCase()}`;
-  const hookContent = `/**
- * ${name} Hooks
- * 
- * Generated by Pattern-Stack CLI
- */
-
-import { useState, useEffect } from 'react'
-
-export function use${name}() {
-  const [data, setData] = useState(null)
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
-
-  // Add your logic here
-
-  return {
-    data,
-    loading,
-    error,
-    refetch: () => {
-      // Implement refetch logic
-    }
-  }
-}`;
-  const componentContent = `/**
- * ${name} Component
- * 
- * Generated by Pattern-Stack CLI
- */
-
-import React from 'react'
-import { use${name} } from '../hooks/use${name}'
-
-export interface ${name}ComponentProps {
-  className?: string
-}
-
-export function ${name}Component({ className }: ${name}ComponentProps) {
-  const { data, loading, error } = use${name}()
-
-  if (loading) return <div>Loading...</div>
-  if (error) return <div>Error: {error.message}</div>
-
-  return (
-    <div className={className}>
-      <h2>${name}</h2>
-      {/* Add your UI here */}
-    </div>
-  )
-}`;
-  const indexContent = `export { use${name} } from './hooks/use${name}'
-export { ${name}Component } from './components/${name}Component'
-export type { ${name}ComponentProps } from './components/${name}Component'`;
-  await ensureDir2((0, import_path4.join)(outputDir, "hooks"));
-  await ensureDir2((0, import_path4.join)(outputDir, "components"));
-  await writeFile2((0, import_path4.join)(outputDir, "hooks", `use${name}.ts`), hookContent);
-  await writeFile2((0, import_path4.join)(outputDir, "hooks", "index.ts"), `export { use${name} } from './use${name}'`);
-  await writeFile2((0, import_path4.join)(outputDir, "components", `${name}Component.tsx`), componentContent);
-  await writeFile2((0, import_path4.join)(outputDir, "components", "index.ts"), `export { ${name}Component } from './${name}Component'`);
-  await writeFile2((0, import_path4.join)(outputDir, "index.ts"), indexContent);
-  console.log(`\u2705 Feature scaffolded: ${outputDir}`);
-}
-async function scaffoldTemplate(name, options) {
-  const outputDir = options.output || `./src/templates/${name.toLowerCase()}`;
-  const templateContent = `/**
- * ${name} Template
- * 
- * Generated by Pattern-Stack CLI
- */
-
-import React from 'react'
-import { PageTemplate } from '../PageTemplate'
-
-export interface ${name}TemplateProps {
-  title?: string
-  children?: React.ReactNode
-}
-
-export function ${name}Template({ 
-  title = "${name}",
-  children 
-}: ${name}TemplateProps) {
-  return (
-    <PageTemplate>
-      <div className="space-y-6">
-        <header>
-          <h1 className="text-3xl font-bold">{title}</h1>
-        </header>
-        
-        <main>
-          {children}
-        </main>
-      </div>
-    </PageTemplate>
-  )
-}`;
-  const indexContent = `export { ${name}Template } from './${name}Template'
-export type { ${name}TemplateProps } from './${name}Template'`;
-  await ensureDir2(outputDir);
-  await writeFile2((0, import_path4.join)(outputDir, `${name}Template.tsx`), templateContent);
-  await writeFile2((0, import_path4.join)(outputDir, "index.ts"), indexContent);
-  console.log(`\u2705 Template scaffolded: ${outputDir}`);
-}
-async function ensureDir2(dir) {
-  try {
-    await import_fs4.promises.mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-}
-async function writeFile2(path, content) {
-  await ensureDir2((0, import_path4.dirname)(path));
-  await import_fs4.promises.writeFile(path, content, "utf8");
-}
-
-// cli/commands/init.ts
-async function initCommand(template = "basic", options) {
-  console.log(`\u{1F680} Initializing Pattern-Stack project with ${template} template`);
-  if (options.name) {
-    console.log(`\u{1F4E6} Project name: ${options.name}`);
-  }
-  if (options.dir) {
-    console.log(`\u{1F4C1} Target directory: ${options.dir}`);
-  }
-  console.log("\n\u26A0\uFE0F  Template initialization not yet implemented");
-  console.log("This feature will be available in a future release.");
-  console.log("\nFor now, you can:");
-  console.log("1. Clone the Pattern-Stack repository");
-  console.log("2. Use the generate hooks command to create API integrations");
-  console.log("3. Use the scaffold command to create components");
-}
-
-// cli/index.ts
-var program = new import_commander.Command();
-program.name("pattern-stack").description("Pattern-Stack CLI for code generation and scaffolding").version("1.0.0");
-var generateCommand = program.command("generate").alias("g").description("Generate code from specifications");
-generateCommand.command("hooks").description("Generate React hooks from OpenAPI specification").argument("<source>", "OpenAPI specification (URL or file path)").option("-o, --output <dir>", "Output directory", "./src/generated").option("--prefix <prefix>", "Type name prefix", "").option("--client <type>", "API client type", "axios").option("--auth <type>", "Authentication type", "bearer").option("--dry-run", "Show what would be generated without writing files").action(generateHooksCommand);
-program.command("scaffold").alias("s").description("Scaffold components and structures").argument("<type>", "Type to scaffold (component, feature, template)").argument("<name>", "Name of the item to scaffold").option("-t, --template <template>", "Template to use").option("-o, --output <dir>", "Output directory").action(scaffoldCommand);
-program.command("init").description("Initialize a new Pattern-Stack project").argument("[template]", "Template to use (financial, ecommerce, analytics)").option("-n, --name <name>", "Project name").option("-d, --dir <directory>", "Target directory").option("--git", "Initialize git repository").option("--install", "Install dependencies").action(initCommand);
-program.command("config").description("Manage Pattern-Stack configuration").option("--show", "Show current configuration").option("--set <key=value>", "Set configuration value").action((options) => {
-  if (options.show) {
-    console.log("Current configuration:");
-  }
-  if (options.set) {
-    const [key, value] = options.set.split("=");
-    console.log(`Setting ${key} = ${value}`);
-  }
-});
-program.command("help").description("Display help for commands").argument("[command]", "Command to get help for").action((command) => {
-  if (command) {
-    program.help();
-  } else {
-    console.log(`
-Pattern-Stack CLI
-
-Available commands:
-  generate hooks <source>     Generate React hooks from OpenAPI spec
-  scaffold <type> <name>      Scaffold components and structures  
-  init [template]             Initialize new project from template
-  config                      Manage configuration
-
-Examples:
-  pattern-stack generate hooks ./api/openapi.json
-  pattern-stack scaffold component UserCard
-  pattern-stack init financial --name my-finance-app
-  
-For more information on a command:
-  pattern-stack <command> --help
-`);
-  }
-});
-program.on("command:*", () => {
-  console.error("Invalid command: %s\nSee --help for a list of available commands.", program.args.join(" "));
-  process.exit(1);
-});
-if (process.argv.length < 3) {
-  program.help();
-} else {
-  program.parse();
-}
-var index_default = program;