@pattern-stack/frontend-patterns 0.0.6 → 0.1.0

package/cli/index.js

@@ -0,0 +1,3210 @@
+#!/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;