@redocly/cli 2.41.2 → 2.43.0

package/lib/chunks/7F5O43EU.js

@@ -1,1756 +0,0 @@
-import { createRequire as __createRequire } from 'node:module';
-const require = __createRequire(import.meta.url);
-import {
-  selectTrafficParser
-} from "./P6UGG7F6.js";
-import {
-  getPathWithoutTrailingSlash,
-  isJsonMime,
-  isSyntheticHost,
-  listFilesRecursively,
-  normalizeContentType,
-  normalizeFsPath,
-  normalizeServerPrefix,
-  resolvePathForServer
-} from "./3CX2Z7JI.js";
-import {
-  OPENAPI3_METHOD_NAMES,
-  Spinner
-} from "./KPMZLKQG.js";
-import {
-  exitWithError
-} from "./T6UZU3XM.js";
-import {
-  createConfig,
-  isPlainObject,
-  lintFromString,
-  logger,
-  parseYaml,
-  pluralize,
-  stringifyYaml
-} from "./Z2664VV5.js";
-import "./Z2I5YXYN.js";
-import "./5ILQMFXK.js";
-
-// src/commands/generate-spec/index.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import path2 from "node:path";
-
-// src/commands/generate-spec/ai/refine.ts
-import * as process2 from "node:process";
-
-// src/commands/generate-spec/value-inference.ts
-var MAX_TRACKED_VALUES = 10;
-var MIN_ENUM_OBSERVATIONS = 4;
-var MAX_ENUM_VALUES = 5;
-var MAX_ENUM_VALUE_LENGTH = 30;
-var ENUM_VALUE_RE = /^[a-zA-Z][a-zA-Z0-9]*(?:[_\-.][a-zA-Z0-9]+)*$/;
-var HEXISH_RE = /^[0-9a-f-]{8,}$/i;
-var FORMAT_MATCHERS = [
-  ["uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i],
-  ["date-time", /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/],
-  ["date", /^\d{4}-\d{2}-\d{2}$/],
-  ["email", /^[^\s@]+@[^\s@]+\.[^\s@]+$/],
-  ["uri", /^https?:\/\/\S+$/],
-  ["ipv4", /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/]
-];
-var observationsByNode = /* @__PURE__ */ new WeakMap();
-function observeString(value) {
-  return {
-    formats: FORMAT_MATCHERS.filter(([, pattern]) => pattern.test(value)).map(([format]) => format),
-    values: [value],
-    count: 1,
-    overflow: false
-  };
-}
-function mergeObservations(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  const merged = {
-    formats: a.formats.filter((format) => b.formats.includes(format)),
-    values: [],
-    count: a.count + b.count,
-    overflow: a.overflow || b.overflow
-  };
-  if (!merged.overflow) {
-    const values = [...a.values];
-    for (const value of b.values) {
-      if (!values.includes(value)) {
-        values.push(value);
-      }
-    }
-    if (values.length > MAX_TRACKED_VALUES) {
-      merged.overflow = true;
-    } else {
-      merged.values = values;
-    }
-  }
-  return merged;
-}
-function setObservations(schema, observations) {
-  observationsByNode.set(schema, observations);
-}
-function getObservations(schema) {
-  return observationsByNode.get(schema);
-}
-function copyObservations(source, target) {
-  const observations = observationsByNode.get(source);
-  if (observations) {
-    observationsByNode.set(target, observations);
-  }
-}
-function isEnumLikeValue(value) {
-  return value.length <= MAX_ENUM_VALUE_LENGTH && !HEXISH_RE.test(value) && ENUM_VALUE_RE.test(value);
-}
-function distillObservations(observations, allowEnum) {
-  if (observations.formats.length > 0) {
-    return { format: observations.formats[0] };
-  }
-  if (allowEnum && !observations.overflow && observations.count >= MIN_ENUM_OBSERVATIONS && observations.values.length > 0 && observations.values.length <= MAX_ENUM_VALUES && observations.values.length * 2 <= observations.count && observations.values.every(isEnumLikeValue)) {
-    return { enum: [...observations.values].sort() };
-  }
-  return {};
-}
-function applyToSchema(schema) {
-  const observations = observationsByNode.get(schema);
-  if (observations) {
-    const types = typeof schema.type === "string" ? [schema.type] : schema.type ?? [];
-    if (types.includes("string")) {
-      Object.assign(schema, distillObservations(observations, types.length === 1));
-    }
-  }
-  for (const property of Object.values(schema.properties ?? {})) {
-    applyToSchema(property);
-  }
-  if (schema.additionalProperties) {
-    applyToSchema(schema.additionalProperties);
-  }
-  if (schema.items) {
-    applyToSchema(schema.items);
-  }
-  for (const member of schema.oneOf ?? []) {
-    applyToSchema(member);
-  }
-}
-function applyValueInference(document) {
-  for (const pathItem of Object.values(document.paths)) {
-    for (const operation of Object.values(pathItem)) {
-      for (const media of Object.values(operation.requestBody?.content ?? {})) {
-        applyToSchema(media.schema);
-      }
-      for (const response of Object.values(operation.responses)) {
-        for (const media of Object.values(response.content ?? {})) {
-          applyToSchema(media.schema);
-        }
-      }
-    }
-  }
-  for (const schema of Object.values(document.components?.schemas ?? {})) {
-    applyToSchema(schema);
-  }
-  return document;
-}
-
-// src/commands/generate-spec/generator.ts
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var NUMERIC_RE = /^\d+$/;
-var ULID_RE = /^[0-9a-hjkmnp-tv-z]{26}$/i;
-var PREFIXED_ID_RE = /^[a-z][a-z0-9]*_(?=[0-9a-z]*\d)[0-9a-z]{10,}$/i;
-var CUID_RE = /^[a-z](?=[a-z0-9]*\d)[a-z0-9]{23,24}$/;
-var HTTP_METHODS = new Set(OPENAPI3_METHOD_NAMES);
-var BODYLESS_METHODS = /* @__PURE__ */ new Set(["get", "head"]);
-var FORM_URLENCODED_MIME = "application/x-www-form-urlencoded";
-var MULTIPART_FORM_MIME = "multipart/form-data";
-function looksLikeIdentifier(segment) {
-  if (!segment) return false;
-  if (NUMERIC_RE.test(segment)) return true;
-  if (UUID_RE.test(segment)) return true;
-  if (ULID_RE.test(segment)) return true;
-  if (PREFIXED_ID_RE.test(segment)) return true;
-  if (CUID_RE.test(segment)) return true;
-  return /^[0-9a-f]{16,}$/i.test(segment);
-}
-function templatizePath(rawPath) {
-  const segments = rawPath.split("/");
-  const params = [];
-  const used = /* @__PURE__ */ new Set();
-  const templated = segments.map((segment, index) => {
-    if (!looksLikeIdentifier(segment)) {
-      return segment;
-    }
-    const previous = segments[index - 1];
-    let name = previous ? `${pluralize(previous, 1)}Id` : "id";
-    let suffix = 1;
-    while (used.has(name)) {
-      suffix += 1;
-      name = previous ? `${pluralize(previous, 1)}Id${suffix}` : `id${suffix}`;
-    }
-    used.add(name);
-    params.push({ name, value: segment });
-    return `{${name}}`;
-  });
-  return { template: templated.join("/") || "/", params };
-}
-function inferSchema(value) {
-  if (value === null) {
-    return { type: "null" };
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return { type: "array" };
-    }
-    const itemSchemas = value.slice(0, 20).map(inferSchema);
-    return { type: "array", items: mergeSchemas(itemSchemas) };
-  }
-  switch (typeof value) {
-    case "string": {
-      const schema = { type: "string" };
-      setObservations(schema, observeString(value));
-      return schema;
-    }
-    case "boolean":
-      return { type: "boolean" };
-    case "number":
-      return Number.isInteger(value) ? { type: "integer" } : { type: "number" };
-    case "object": {
-      const entries = Object.entries(value);
-      if (entries.length > 0) {
-        const keysAreGeneric = entries.every(([key]) => NUMERIC_RE.test(key)) || entries.every(([key]) => UUID_RE.test(key));
-        if (keysAreGeneric) {
-          return {
-            type: "object",
-            additionalProperties: mergeSchemas(
-              entries.map(([, propValue]) => inferSchema(propValue))
-            )
-          };
-        }
-      }
-      const properties = {};
-      const required = [];
-      for (const [key, propValue] of entries) {
-        properties[key] = inferSchema(propValue);
-        required.push(key);
-      }
-      const schema = { type: "object", properties };
-      if (required.length > 0) {
-        schema.required = required;
-      }
-      return schema;
-    }
-    default:
-      return {};
-  }
-}
-function mergeSchemas(schemas) {
-  if (schemas.length === 0) {
-    return {};
-  }
-  const [first, ...rest] = schemas;
-  let merged = first;
-  for (const next of rest) {
-    merged = mergeTwo(merged, next);
-  }
-  return merged;
-}
-function isUnconstrainedSchema(schema) {
-  return Object.keys(schema).length === 0;
-}
-function variantKind(variant) {
-  if (variant.additionalProperties) {
-    return "map";
-  }
-  if (variant.type === "object") {
-    return "object";
-  }
-  if (variant.type === "array") {
-    return "array";
-  }
-  return "scalar";
-}
-function toVariants(schema) {
-  if (schema.oneOf) {
-    return schema.oneOf.flatMap(toVariants);
-  }
-  if (Array.isArray(schema.type)) {
-    return schema.type.map((type) => {
-      if (type === "object") {
-        const variant = { type: "object" };
-        if (schema.properties) {
-          variant.properties = schema.properties;
-        }
-        if (schema.required) {
-          variant.required = schema.required;
-        }
-        if (schema.additionalProperties) {
-          variant.additionalProperties = schema.additionalProperties;
-        }
-        return variant;
-      }
-      if (type === "array") {
-        return schema.items ? { type: "array", items: schema.items } : { type: "array" };
-      }
-      const scalar = { type };
-      if (type === "string") {
-        copyObservations(schema, scalar);
-      }
-      return scalar;
-    });
-  }
-  return [schema];
-}
-var OBJECT_MERGE_SIMILARITY = 0.5;
-var MAX_OBJECT_VARIANTS = 3;
-function objectSimilarity(a, b) {
-  const keysA = Object.keys(a.properties ?? {});
-  const keysB = Object.keys(b.properties ?? {});
-  if (keysA.length === 0 || keysB.length === 0) {
-    return 1;
-  }
-  const setB = new Set(keysB);
-  const shared = keysA.filter((key) => setB.has(key)).length;
-  return shared / (keysA.length + keysB.length - shared);
-}
-function areCompatibleVariants(a, b) {
-  const kind = variantKind(a);
-  if (kind !== variantKind(b)) {
-    return false;
-  }
-  switch (kind) {
-    case "scalar":
-      return a.type === b.type || a.type === "integer" && b.type === "number" || a.type === "number" && b.type === "integer";
-    case "object":
-      return objectSimilarity(a, b) >= OBJECT_MERGE_SIMILARITY;
-    default:
-      return true;
-  }
-}
-function mergeVariantPair(a, b) {
-  switch (variantKind(a)) {
-    case "scalar": {
-      if (a.type !== b.type) {
-        return { type: "number" };
-      }
-      if (a.type === "string") {
-        const observations = mergeObservations(getObservations(a), getObservations(b));
-        if (observations) {
-          const merged = { type: "string" };
-          setObservations(merged, observations);
-          return merged;
-        }
-      }
-      return a;
-    }
-    case "map":
-      return {
-        type: "object",
-        additionalProperties: mergeTwo(a.additionalProperties ?? {}, b.additionalProperties ?? {})
-      };
-    case "object": {
-      const properties = { ...a.properties ?? {} };
-      for (const [key, schema] of Object.entries(b.properties ?? {})) {
-        properties[key] = properties[key] ? mergeTwo(properties[key], schema) : schema;
-      }
-      const requiredB = new Set(b.required ?? []);
-      const required = (a.required ?? []).filter((key) => requiredB.has(key));
-      const merged = { type: "object", properties };
-      if (required.length > 0) {
-        merged.required = required;
-      }
-      return merged;
-    }
-    case "array": {
-      if (!a.items || !b.items) {
-        const items = a.items ?? b.items;
-        return items ? { type: "array", items } : { type: "array" };
-      }
-      return { type: "array", items: mergeTwo(a.items, b.items) };
-    }
-  }
-}
-function foldExcessObjectVariants(variants) {
-  const result = [...variants];
-  const objectCount = () => result.filter((v) => variantKind(v) === "object").length;
-  while (objectCount() > MAX_OBJECT_VARIANTS) {
-    let bestA = -1;
-    let bestB = -1;
-    let bestScore = -1;
-    for (let i = 0; i < result.length; i++) {
-      if (variantKind(result[i]) !== "object") continue;
-      for (let j = i + 1; j < result.length; j++) {
-        if (variantKind(result[j]) !== "object") continue;
-        const score = objectSimilarity(result[i], result[j]);
-        if (score > bestScore) {
-          bestScore = score;
-          bestA = i;
-          bestB = j;
-        }
-      }
-    }
-    result[bestA] = mergeVariantPair(result[bestA], result[bestB]);
-    result.splice(bestB, 1);
-  }
-  return result;
-}
-var SCALAR_TYPE_ORDER = ["boolean", "integer", "number", "string", "null"];
-function finalizeVariants(variants) {
-  if (variants.length === 1) {
-    return variants[0];
-  }
-  const structured = [];
-  const scalarTypes2 = /* @__PURE__ */ new Set();
-  let stringObservations;
-  for (const variant of variants) {
-    if (variantKind(variant) === "scalar" && typeof variant.type === "string") {
-      scalarTypes2.add(variant.type);
-      if (variant.type === "string") {
-        stringObservations = mergeObservations(stringObservations, getObservations(variant));
-      }
-    } else {
-      structured.push(variant);
-    }
-  }
-  const orderedScalars = SCALAR_TYPE_ORDER.filter((type) => scalarTypes2.has(type));
-  const scalarSchema = (type) => {
-    const schema = { type };
-    const includesString = typeof type === "string" ? type === "string" : type.includes("string");
-    if (includesString && stringObservations) {
-      setObservations(schema, stringObservations);
-    }
-    return schema;
-  };
-  if (structured.length === 0) {
-    return orderedScalars.length === 1 ? scalarSchema(orderedScalars[0]) : scalarSchema(orderedScalars);
-  }
-  if (structured.length === 1 && orderedScalars.length === 1 && orderedScalars[0] === "null" && typeof structured[0].type === "string") {
-    return { ...structured[0], type: [structured[0].type, "null"] };
-  }
-  const members = [...structured];
-  if (orderedScalars.length === 1) {
-    members.push(scalarSchema(orderedScalars[0]));
-  } else if (orderedScalars.length > 1) {
-    members.push(scalarSchema(orderedScalars));
-  }
-  return { oneOf: members };
-}
-function mergeTwo(a, b) {
-  if (isUnconstrainedSchema(a) || isUnconstrainedSchema(b)) {
-    return {};
-  }
-  const variants = toVariants(a);
-  for (const candidate of toVariants(b)) {
-    const index = variants.findIndex((variant) => areCompatibleVariants(variant, candidate));
-    if (index === -1) {
-      variants.push(candidate);
-    } else {
-      variants[index] = mergeVariantPair(variants[index], candidate);
-    }
-  }
-  return finalizeVariants(foldExcessObjectVariants(variants));
-}
-function sniffJson(bodyText) {
-  if (!bodyText) {
-    return void 0;
-  }
-  const trimmed = bodyText.trim();
-  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-    return void 0;
-  }
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return void 0;
-  }
-}
-function inferMultipartSchema(bodyText, contentType) {
-  const boundary = contentType?.match(/boundary="?([^";,]+)"?/i)?.[1];
-  if (!boundary) {
-    return void 0;
-  }
-  const properties = {};
-  for (const section of bodyText.split(`--${boundary}`)) {
-    const partMatch = section.match(/^\r?\n([\s\S]*?)\r?\n\r?\n([\s\S]*)\r?\n$/);
-    if (!partMatch) {
-      continue;
-    }
-    const [, partHeaders, value] = partMatch;
-    const fieldName = partHeaders.match(/\bname="([^"]*)"/i)?.[1];
-    if (fieldName === void 0) {
-      continue;
-    }
-    properties[fieldName] = /\bfilename="/i.test(partHeaders) ? { type: "string", format: "binary" } : inferSchema(value);
-  }
-  if (Object.keys(properties).length === 0) {
-    return void 0;
-  }
-  return { type: "object", properties, required: Object.keys(properties) };
-}
-function inferBodySchema(message) {
-  const mime = normalizeContentType(message.contentType);
-  if (message.bodyJson !== void 0) {
-    return {
-      mime: isJsonMime(mime) ? mime : "application/json",
-      schema: inferSchema(message.bodyJson)
-    };
-  }
-  if (mime === FORM_URLENCODED_MIME && message.bodyText) {
-    const fields = {};
-    for (const [key, value] of new URLSearchParams(message.bodyText)) {
-      fields[key] = value;
-    }
-    if (Object.keys(fields).length === 0) {
-      return void 0;
-    }
-    return { mime: FORM_URLENCODED_MIME, schema: inferSchema(fields) };
-  }
-  if (mime === MULTIPART_FORM_MIME && message.bodyText) {
-    const schema = inferMultipartSchema(message.bodyText, message.contentType);
-    return schema ? { mime: MULTIPART_FORM_MIME, schema } : void 0;
-  }
-  const sniffed = sniffJson(message.bodyText);
-  if (sniffed !== void 0) {
-    return { mime: "application/json", schema: inferSchema(sniffed) };
-  }
-  return void 0;
-}
-function accumulateBodySchema(target, mime, schema) {
-  const merged = target.get(mime);
-  target.set(mime, merged ? mergeSchemas([merged, schema]) : schema);
-}
-async function generateSpecFromTraffic(options) {
-  const trafficFiles = await listFilesRecursively(options.trafficPath);
-  if (trafficFiles.length === 0) {
-    throw new Error("No traffic files found in the provided traffic path.");
-  }
-  const server = normalizeServerPrefix(options.server);
-  const operations = /* @__PURE__ */ new Map();
-  const observedServers = /* @__PURE__ */ new Set();
-  let supportedTrafficFileCount = 0;
-  const observe = (exchange) => {
-    const method = exchange.request.method.toLowerCase();
-    if (!HTTP_METHODS.has(method)) {
-      return;
-    }
-    let rawPath = exchange.request.path || "/";
-    if (server) {
-      const serverRelativePath = resolvePathForServer(exchange.request, server);
-      if (serverRelativePath === void 0) {
-        return;
-      }
-      rawPath = serverRelativePath;
-    } else if (exchange.request.host && !isSyntheticHost(exchange.request.host)) {
-      observedServers.add(`${exchange.request.protocol}//${exchange.request.host}`);
-    }
-    const { template, params } = templatizePath(getPathWithoutTrailingSlash(rawPath));
-    const key = `${method} ${template}`;
-    let accumulator = operations.get(key);
-    if (!accumulator) {
-      accumulator = {
-        method,
-        template,
-        pathParams: /* @__PURE__ */ new Map(),
-        queryParams: /* @__PURE__ */ new Map(),
-        requestBodies: /* @__PURE__ */ new Map(),
-        responses: /* @__PURE__ */ new Map()
-      };
-      operations.set(key, accumulator);
-    }
-    for (const { name, value } of params) {
-      const previous = accumulator.pathParams.get(name);
-      accumulator.pathParams.set(name, {
-        numeric: (previous?.numeric ?? true) && NUMERIC_RE.test(value),
-        observations: mergeObservations(previous?.observations, observeString(value))
-      });
-    }
-    for (const queryKey of new Set(exchange.request.query.keys())) {
-      const values = exchange.request.query.getAll(queryKey);
-      const previous = accumulator.queryParams.get(queryKey);
-      const isNumeric = values.length > 0 && values.every((value) => NUMERIC_RE.test(value));
-      let observations = previous?.observations;
-      for (const value of values) {
-        observations = mergeObservations(observations, observeString(value));
-      }
-      accumulator.queryParams.set(queryKey, {
-        numeric: (previous?.numeric ?? true) && isNumeric,
-        observations
-      });
-    }
-    if (!BODYLESS_METHODS.has(method)) {
-      const requestBody = inferBodySchema(exchange.request);
-      if (requestBody) {
-        accumulateBodySchema(accumulator.requestBodies, requestBody.mime, requestBody.schema);
-      }
-    }
-    if (exchange.response && exchange.response.status >= 100) {
-      const status = String(exchange.response.status);
-      let responseAccumulator = accumulator.responses.get(status);
-      if (!responseAccumulator) {
-        responseAccumulator = { bodies: /* @__PURE__ */ new Map() };
-        accumulator.responses.set(status, responseAccumulator);
-      }
-      responseAccumulator.statusText ??= exchange.response.statusText || void 0;
-      const responseBody = inferBodySchema(exchange.response);
-      if (responseBody) {
-        accumulateBodySchema(responseAccumulator.bodies, responseBody.mime, responseBody.schema);
-      }
-    }
-  };
-  for (const trafficFile of trafficFiles) {
-    const parser = await selectTrafficParser(trafficFile, options.format);
-    if (!parser) {
-      logger.warn(`Skipping traffic file with unrecognized format: ${trafficFile}
-`);
-      continue;
-    }
-    supportedTrafficFileCount += 1;
-    for await (const exchange of parser.parse(trafficFile)) {
-      observe(exchange);
-    }
-  }
-  if (supportedTrafficFileCount === 0) {
-    throw new Error("No supported traffic files found to generate an OpenAPI description from.");
-  }
-  if (operations.size === 0) {
-    throw new Error(
-      server ? `No HTTP exchanges in the traffic matched the server "${server}".` : "No HTTP exchanges were observed in the traffic. Cannot generate an OpenAPI description."
-    );
-  }
-  const serverUrls = server ? [server] : Array.from(observedServers).sort();
-  return buildDocument(operations, options.title ?? "Generated API", serverUrls);
-}
-function countOperations(document) {
-  return Object.values(document.paths).reduce(
-    (total, pathItem) => total + Object.keys(pathItem).length,
-    0
-  );
-}
-function parameterSchema(param, allowEnum) {
-  if (param.numeric) {
-    return { type: "integer" };
-  }
-  const schema = { type: "string" };
-  if (param.observations) {
-    Object.assign(schema, distillObservations(param.observations, allowEnum));
-  }
-  return schema;
-}
-function buildDocument(operations, title, serverUrls) {
-  const paths = {};
-  for (const accumulator of operations.values()) {
-    const pathItem = paths[accumulator.template] ??= {};
-    const parameters = [
-      ...Array.from(accumulator.pathParams).map(
-        ([name, param]) => ({
-          name,
-          in: "path",
-          required: true,
-          schema: parameterSchema(param, false)
-        })
-      ),
-      ...Array.from(accumulator.queryParams).map(
-        ([name, param]) => ({
-          name,
-          in: "query",
-          required: false,
-          schema: parameterSchema(param, true)
-        })
-      )
-    ];
-    const operation = {
-      operationId: deriveOperationId(accumulator.method, accumulator.template),
-      responses: {}
-    };
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (accumulator.requestBodies.size > 0) {
-      const content = {};
-      for (const [mime, schema] of accumulator.requestBodies) {
-        content[mime] = { schema };
-      }
-      operation.requestBody = { content };
-    }
-    if (accumulator.responses.size === 0) {
-      operation.responses["default"] = { description: "Observed response" };
-    } else {
-      for (const [status, responseAccumulator] of accumulator.responses) {
-        const response = {
-          description: responseAccumulator.statusText || "Observed response"
-        };
-        if (responseAccumulator.bodies.size > 0) {
-          const content = {};
-          for (const [mime, schema] of responseAccumulator.bodies) {
-            content[mime] = { schema };
-          }
-          response.content = content;
-        }
-        operation.responses[status] = response;
-      }
-    }
-    pathItem[accumulator.method] = operation;
-  }
-  return {
-    openapi: "3.2.0",
-    info: { title, version: "1.0.0" },
-    ...serverUrls.length > 0 ? { servers: serverUrls.map((url) => ({ url })) } : {},
-    paths
-  };
-}
-function deriveOperationId(method, template) {
-  const cleaned = template.split("/").filter(Boolean).map((segment) => segment.replace(/[{}]/g, "")).join("-");
-  return `${method}-${cleaned || "root"}`;
-}
-
-// src/commands/generate-spec/samples.ts
-function operationSampleKey(method, template) {
-  return `${method.toUpperCase()} ${template}`;
-}
-function snapshotBody(message, maxBodyChars) {
-  let text;
-  if (message.bodyJson !== void 0) {
-    try {
-      text = JSON.stringify(message.bodyJson);
-    } catch {
-      text = void 0;
-    }
-  }
-  text ??= message.bodyText;
-  if (!text) {
-    return void 0;
-  }
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return trimmed.length > maxBodyChars ? `${trimmed.slice(0, maxBodyChars)}\u2026[truncated]` : trimmed;
-}
-function shapeSignature(message) {
-  if (!message) {
-    return "";
-  }
-  const value = message.bodyJson;
-  if (value === void 0) {
-    return message.bodyText ? normalizeContentType(message.contentType) || "text" : "";
-  }
-  if (value === null) {
-    return "null";
-  }
-  if (Array.isArray(value)) {
-    return `array<${value.length > 0 ? shapeOfValue(value[0]) : ""}>`;
-  }
-  return shapeOfValue(value);
-}
-function shapeOfValue(value) {
-  if (isPlainObject(value)) {
-    return Object.keys(value).sort().join(",");
-  }
-  return value === null ? "null" : typeof value;
-}
-async function collectTrafficSamples(options) {
-  const perGroup = options.perGroup ?? 2;
-  const perOperation = options.perOperation ?? 4;
-  const maxBodyChars = options.maxBodyChars ?? 2e3;
-  const server = normalizeServerPrefix(options.server);
-  const trafficFiles = await listFilesRecursively(options.trafficPath);
-  const operations = /* @__PURE__ */ new Map();
-  for (const trafficFile of trafficFiles) {
-    const parser = await selectTrafficParser(trafficFile, options.format);
-    if (!parser) {
-      continue;
-    }
-    for await (const exchange of parser.parse(trafficFile)) {
-      const method = exchange.request.method.toUpperCase();
-      if (!HTTP_METHODS.has(method.toLowerCase())) {
-        continue;
-      }
-      let rawPath = exchange.request.path || "/";
-      if (server) {
-        const serverRelativePath = resolvePathForServer(exchange.request, server);
-        if (serverRelativePath === void 0) {
-          continue;
-        }
-        rawPath = serverRelativePath;
-      }
-      const path3 = getPathWithoutTrailingSlash(rawPath);
-      const { template } = templatizePath(path3);
-      const response = exchange.response && exchange.response.status >= 100 ? exchange.response : void 0;
-      const status = response?.status;
-      const shape = `${shapeSignature(exchange.request)}\u2192${shapeSignature(response)}`;
-      let groups = operations.get(operationSampleKey(method, template));
-      if (!groups) {
-        groups = /* @__PURE__ */ new Map();
-        operations.set(operationSampleKey(method, template), groups);
-      }
-      const groupKey = `${status ?? ""} ${shape}`;
-      let group = groups.get(groupKey);
-      if (!group) {
-        group = [];
-        groups.set(groupKey, group);
-      }
-      if (group.length >= perGroup) {
-        continue;
-      }
-      group.push({
-        method,
-        path: path3,
-        query: exchange.request.query.toString(),
-        status,
-        requestContentType: exchange.request.contentType,
-        requestBody: snapshotBody(exchange.request, maxBodyChars),
-        responseContentType: response?.contentType,
-        responseBody: response ? snapshotBody(response, maxBodyChars) : void 0
-      });
-    }
-  }
-  const samplesByOperation = /* @__PURE__ */ new Map();
-  for (const [operationKey, groups] of operations) {
-    const samples = [];
-    for (let round = 0; round < perGroup && samples.length < perOperation; round++) {
-      for (const group of groups.values()) {
-        if (samples.length >= perOperation) {
-          break;
-        }
-        if (group[round]) {
-          samples.push(group[round]);
-        }
-      }
-    }
-    samplesByOperation.set(operationKey, samples);
-  }
-  return samplesByOperation;
-}
-
-// src/commands/generate-spec/ai/prompt.ts
-var SYSTEM_INSTRUCTIONS = `You are an expert API designer. You are given one operation from an OpenAPI 3.2 description that was inferred mechanically from recorded HTTP traffic, the component schemas it references, and a sample of the real recorded HTTP exchanges for that operation. The inferred description is only a hypothesis: types are coarse, every observed property is marked required, and descriptions are missing. Alternative body shapes observed in the traffic appear as "oneOf" variants or type unions. Common string formats (uuid, date-time, date, email, uri, ipv4) and small closed enums are detected conservatively from the observed values.
-
-Refine the operation into the most accurate OpenAPI 3.2 definition you can justify from the evidence, while staying conservative:
-- Keep the path template and the HTTP method exactly as given. Do not rename path parameters, do not move parameters to the path item level, and keep every response status code. The result is programmatically checked and rejected otherwise.
-- Keep the operationId unless it is clearly wrong.
-- Narrow property types where the samples clearly support it (formats such as date-time, uuid, email, uri; integer vs number; enums when a field only ever takes a small fixed set of values). Verify the formats and enums already detected against the samples; correct or extend them where justified. The detected formats and enums were derived from the full recorded traffic while you see only a subset of it, so never remove a detected format or enum value merely because the samples do not show it \u2014 correct one only when a sample contradicts it.
-- Relax "required" for properties that are plausibly optional (e.g. absent in some samples, or clearly nullable). Express nullable values as type unions such as ["string", "null"].
-- When a request or response body has alternative shapes \u2014 the baseline shows "oneOf" variants, or the samples show clearly different payloads \u2014 model them explicitly with "oneOf". Name each variant in components/schemas, and add a "discriminator" when a property (such as "type" or "kind") selects the variant.
-- Factor structure shared between variants or schemas with "allOf": extract the common base into components/schemas and compose each variant as "allOf" of the base plus its specific properties.
-- Keep the $ref references to the component schemas you were given. You may refine the definition of a referenced component when the samples justify it, and you may add new components, but never rename an existing component and never reuse a reserved component name listed in the input.
-- Add concise, useful "summary" and "description" fields to the operation, its parameters and important schema properties.
-- Add example values drawn from the real samples where helpful, but never copy values that look like secrets or personal data (tokens, API keys, passwords, session identifiers, email addresses, personal names); use clearly fictional placeholder values instead.
-
-Output ONLY a YAML document with this exact top-level structure:
-
-paths:
-  <the path template exactly as given>:
-    <the method>:
-      ...the refined operation...
-components:
-  schemas:
-    ...only the component schemas you changed or added; omit "components" entirely when there are none...
-
-Do not wrap the output in Markdown code fences. Do not add any commentary before or after the document.`;
-function renderSamples(samples) {
-  if (samples.length === 0) {
-    return "(no sample exchanges were captured)";
-  }
-  return samples.map((sample, index) => {
-    const lines = [];
-    const query = sample.query ? `?${sample.query}` : "";
-    lines.push(`### Exchange ${index + 1}`);
-    lines.push(`${sample.method} ${sample.path}${query}`);
-    if (sample.requestContentType) {
-      lines.push(`Request Content-Type: ${sample.requestContentType}`);
-    }
-    if (sample.requestBody) {
-      lines.push(`Request body: ${sample.requestBody}`);
-    }
-    if (sample.status !== void 0) {
-      lines.push(`Response status: ${sample.status}`);
-    }
-    if (sample.responseContentType) {
-      lines.push(`Response Content-Type: ${sample.responseContentType}`);
-    }
-    if (sample.responseBody) {
-      lines.push(`Response body: ${sample.responseBody}`);
-    }
-    return lines.join("\n");
-  }).join("\n\n");
-}
-function buildOperationPrompt(options) {
-  const sections = [];
-  sections.push(
-    `# Operation to refine (inferred from traffic)
-
-\`\`\`yaml
-${stringifyYaml({
-      paths: { [options.path]: { [options.method]: options.operation } }
-    })}\`\`\``
-  );
-  if (Object.keys(options.components).length > 0) {
-    sections.push(
-      `# Component schemas referenced by this operation (current definitions)
-
-\`\`\`yaml
-${stringifyYaml(
-        { components: { schemas: options.components } }
-      )}\`\`\``
-    );
-  }
-  if (options.reservedComponentNames.length > 0) {
-    sections.push(
-      `# Reserved component names (used elsewhere in the description; do not redefine or reuse them)
-
-${options.reservedComponentNames.join(
-        ", "
-      )}`
-    );
-  }
-  sections.push(
-    `# Recorded HTTP exchanges for this operation
-
-${renderSamples(options.samples)}`
-  );
-  sections.push(
-    `Refine ${options.method.toUpperCase()} ${options.path} as instructed and output only the YAML document.`
-  );
-  return { system: SYSTEM_INSTRUCTIONS, user: sections.join("\n\n") };
-}
-
-// src/commands/generate-spec/ai/providers.ts
-import { spawn } from "node:child_process";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var AI_RESPONSE_TIMEOUT_MS = 3e5;
-var CliNotFoundError = class extends Error {
-};
-var emptyCwdPromise;
-function getEmptyCwd() {
-  emptyCwdPromise ??= mkdtemp(path.join(tmpdir(), "redocly-generate-spec-"));
-  return emptyCwdPromise;
-}
-async function runCommand(command, args, stdin, env) {
-  const cwd = await getEmptyCwd();
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd,
-      env: { ...process.env, ...env }
-    });
-    let stdout = "";
-    let stderr2 = "";
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGKILL");
-    }, AI_RESPONSE_TIMEOUT_MS);
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr2 += chunk.toString();
-    });
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      if (error.code === "ENOENT") {
-        reject(
-          new CliNotFoundError(`Could not find the "${command}" CLI on PATH. Is it installed?`)
-        );
-        return;
-      }
-      reject(error);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (timedOut) {
-        reject(
-          new Error(
-            `The "${command}" CLI did not respond within ${AI_RESPONSE_TIMEOUT_MS / 1e3} seconds.`
-          )
-        );
-        return;
-      }
-      resolve({ stdout, stderr: stderr2, code });
-    });
-    child.stdin.on("error", () => {
-    });
-    child.stdin.end(stdin);
-  });
-}
-async function runClaude(request) {
-  const args = [
-    "-p",
-    "--output-format",
-    "text",
-    "--tools",
-    "",
-    "--strict-mcp-config",
-    "--setting-sources",
-    "",
-    "--no-session-persistence",
-    "--append-system-prompt",
-    request.system
-  ];
-  if (request.model) {
-    args.push("--model", request.model);
-  }
-  const { stdout, stderr: stderr2, code } = await runCommand("claude", args, request.user, {
-    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
-  });
-  if (code !== 0) {
-    throw new Error(`claude CLI exited with code ${code}: ${stderr2.trim()}`);
-  }
-  if (!stdout.trim()) {
-    throw new Error("claude CLI returned no output.");
-  }
-  return { text: stdout };
-}
-async function runCodex(request) {
-  const args = [
-    "exec",
-    "--skip-git-repo-check",
-    "--sandbox",
-    "read-only",
-    "-c",
-    "mcp_servers={}",
-    "-c",
-    "project_doc_max_bytes=0"
-  ];
-  if (request.model) {
-    args.push("--model", request.model);
-  }
-  args.push("-");
-  const prompt = `${request.system}
-
-${request.user}`;
-  const { stdout, stderr: stderr2, code } = await runCommand("codex", args, prompt);
-  if (code !== 0) {
-    throw new Error(`codex CLI exited with code ${code}: ${stderr2.trim()}`);
-  }
-  if (!stdout.trim()) {
-    throw new Error("codex CLI returned no output.");
-  }
-  return { text: stdout };
-}
-async function runCursor(request) {
-  const args = ["-p", "--output-format", "text", "--trust"];
-  if (request.model) {
-    args.push("--model", request.model);
-  }
-  const prompt = `${request.system}
-
-${request.user}`;
-  let result;
-  try {
-    result = await runCommand("cursor-agent", args, prompt);
-  } catch (error) {
-    if (!(error instanceof CliNotFoundError)) {
-      throw error;
-    }
-    try {
-      result = await runCommand("agent", args, prompt);
-    } catch (fallbackError) {
-      if (fallbackError instanceof CliNotFoundError) {
-        throw new CliNotFoundError(
-          'Could not find the Cursor CLI ("cursor-agent" or "agent") on PATH. Is it installed?'
-        );
-      }
-      throw fallbackError;
-    }
-  }
-  const { stdout, stderr: stderr2, code } = result;
-  if (code !== 0) {
-    throw new Error(`cursor CLI exited with code ${code}: ${stderr2.trim()}`);
-  }
-  if (!stdout.trim()) {
-    throw new Error("cursor CLI returned no output.");
-  }
-  return { text: stdout };
-}
-async function runProvider(provider, request) {
-  switch (provider) {
-    case "claude":
-      return runClaude(request);
-    case "codex":
-      return runCodex(request);
-    case "cursor":
-      return runCursor(request);
-    default:
-      throw new Error(`Unknown AI provider: ${provider}`);
-  }
-}
-
-// src/commands/generate-spec/ai/refine.ts
-function stripCodeFences(text) {
-  const trimmed = text.trim();
-  const fenceMatch = trimmed.match(/^```(?:ya?ml|json)?\s*\n([\s\S]*?)\n```$/);
-  return fenceMatch ? fenceMatch[1] : trimmed;
-}
-var COMPONENT_REF_RE = /^#\/components\/schemas\/(.+)$/;
-function collectComponentRefs(value, into) {
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      collectComponentRefs(item, into);
-    }
-    return;
-  }
-  if (!isPlainObject(value)) {
-    return;
-  }
-  if (typeof value.$ref === "string") {
-    const refMatch = value.$ref.match(COMPONENT_REF_RE);
-    if (refMatch) {
-      into.add(refMatch[1]);
-    }
-  }
-  if (isPlainObject(value.discriminator) && isPlainObject(value.discriminator.mapping)) {
-    for (const target of Object.values(value.discriminator.mapping)) {
-      if (typeof target === "string") {
-        const mappingRefMatch = target.match(COMPONENT_REF_RE);
-        into.add(mappingRefMatch ? mappingRefMatch[1] : target);
-      }
-    }
-  }
-  for (const child of Object.values(value)) {
-    collectComponentRefs(child, into);
-  }
-}
-function transitivelyReferencedComponents(root, schemas) {
-  const referenced = /* @__PURE__ */ new Set();
-  const pending = [root];
-  while (pending.length > 0) {
-    const names = /* @__PURE__ */ new Set();
-    collectComponentRefs(pending.pop(), names);
-    for (const name of names) {
-      if (!referenced.has(name) && name in schemas) {
-        referenced.add(name);
-        pending.push(schemas[name]);
-      }
-    }
-  }
-  return referenced;
-}
-function pruneUnusedComponents(document) {
-  const schemas = document.components?.schemas;
-  if (!schemas) {
-    return;
-  }
-  const used = transitivelyReferencedComponents(document.paths, schemas);
-  for (const name of Object.keys(schemas)) {
-    if (!used.has(name)) {
-      delete schemas[name];
-    }
-  }
-  if (Object.keys(schemas).length === 0) {
-    delete document.components;
-  }
-}
-function parseOperationFragment(text, path3, method) {
-  const cleaned = stripCodeFences(text);
-  let parsed;
-  try {
-    parsed = parseYaml(cleaned);
-  } catch (error) {
-    throw new Error(
-      `the provider did not return valid YAML: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (!isPlainObject(parsed)) {
-    throw new Error('the response is not a YAML document with a "paths" object');
-  }
-  const paths = parsed.paths;
-  if (!isPlainObject(paths)) {
-    throw new Error('the response is not a YAML document with a "paths" object');
-  }
-  const pathItem = paths[path3];
-  if (!isPlainObject(pathItem)) {
-    throw new Error(`the response does not keep the path template "${path3}"`);
-  }
-  const operation = pathItem[method];
-  if (!isPlainObject(operation)) {
-    throw new Error(`the response does not contain the ${method.toUpperCase()} operation`);
-  }
-  const components = parsed.components;
-  const schemas = isPlainObject(components) ? components.schemas : void 0;
-  return { operation, components: isPlainObject(schemas) ? schemas : {} };
-}
-function missingStatuses(baselineOperation, refinedOperation) {
-  const responses = isPlainObject(refinedOperation.responses) ? refinedOperation.responses : {};
-  return Object.keys(baselineOperation.responses).filter((status) => !(status in responses));
-}
-async function lintDocumentSource(source, config) {
-  const problems = await lintFromString({ source, config });
-  const errors = problems.filter((problem) => problem.severity === "error");
-  if (errors.length > 0) {
-    const summary = errors.slice(0, 5).map((problem) => `${problem.ruleId}: ${problem.message}`).join("; ");
-    throw new Error(`the result has ${errors.length} validation problem(s): ${summary}`);
-  }
-}
-async function refineOperation(options) {
-  const schemas = options.document.components?.schemas ?? {};
-  const referenced = transitivelyReferencedComponents(options.operation, schemas);
-  const components = {};
-  for (const name of referenced) {
-    components[name] = schemas[name];
-  }
-  const reservedComponentNames = Object.keys(schemas).filter((name) => !referenced.has(name));
-  const { system, user } = buildOperationPrompt({
-    path: options.path,
-    method: options.method,
-    operation: options.operation,
-    components,
-    reservedComponentNames,
-    samples: options.samples
-  });
-  const { text } = await runProvider(options.provider, { system, user, model: options.model });
-  const fragment = parseOperationFragment(text, options.path, options.method);
-  const dropped = missingStatuses(options.operation, fragment.operation);
-  if (dropped.length > 0) {
-    throw new Error(`the response dropped observed response status(es): ${dropped.join(", ")}`);
-  }
-  if (typeof fragment.operation.operationId !== "string") {
-    throw new Error("the response dropped the operationId");
-  }
-  const redefined = Object.keys(fragment.components).filter(
-    (name) => reservedComponentNames.includes(name)
-  );
-  if (redefined.length > 0) {
-    throw new Error(`the response redefines reserved component(s): ${redefined.join(", ")}`);
-  }
-  const fragmentDocument = {
-    openapi: options.document.openapi,
-    info: options.document.info,
-    paths: { [options.path]: { [options.method]: fragment.operation } },
-    components: { schemas: { ...schemas, ...fragment.components } }
-  };
-  await lintDocumentSource(stringifyYaml(fragmentDocument), options.config);
-  return fragment;
-}
-function applyFragment(document, path3, method, fragment) {
-  document.paths[path3][method] = fragment.operation;
-  if (Object.keys(fragment.components).length > 0) {
-    document.components ??= { schemas: {} };
-    Object.assign(document.components.schemas, fragment.components);
-  }
-}
-function finishProgress(spinner) {
-  spinner.stop();
-  if (process2.stderr.isTTY) {
-    logger.info("\x1B[2K");
-  }
-}
-async function refineSpecWithAi(options) {
-  const document = structuredClone(options.baseline);
-  const config = await createConfig({ extends: ["spec"] });
-  const operations = [];
-  for (const [path3, pathItem] of Object.entries(options.baseline.paths)) {
-    for (const [method, operation] of Object.entries(pathItem)) {
-      operations.push({ path: path3, method, operation });
-    }
-  }
-  const spinner = new Spinner();
-  const inFlight = /* @__PURE__ */ new Set();
-  let completed = 0;
-  let refined = 0;
-  const updateSpinner = () => {
-    const [firstLabel] = inFlight;
-    if (!firstLabel) {
-      return;
-    }
-    const others = inFlight.size > 1 ? ` (+${inFlight.size - 1} more)` : "";
-    spinner.start(`[${completed + 1}/${operations.length}] Refining ${firstLabel}${others}`);
-  };
-  let nextIndex = 0;
-  let aborted = false;
-  const worker = async () => {
-    while (!aborted && nextIndex < operations.length) {
-      const { path: path3, method, operation } = operations[nextIndex++];
-      const label = `${method.toUpperCase()} ${path3}`;
-      const startedAt = Date.now();
-      inFlight.add(label);
-      updateSpinner();
-      try {
-        const fragment = await refineOperation({
-          provider: options.provider,
-          model: options.model,
-          document,
-          path: path3,
-          method,
-          operation,
-          samples: options.samplesByOperation.get(operationSampleKey(method, path3)) ?? [],
-          config
-        });
-        applyFragment(document, path3, method, fragment);
-        refined += 1;
-        completed += 1;
-        inFlight.delete(label);
-        finishProgress(spinner);
-        logger.info(
-          `[${completed}/${operations.length}] ${label} \u2014 refined (${Math.round(
-            (Date.now() - startedAt) / 1e3
-          )}s)
-`
-        );
-      } catch (error) {
-        completed += 1;
-        inFlight.delete(label);
-        finishProgress(spinner);
-        if (error instanceof CliNotFoundError) {
-          aborted = true;
-          throw error;
-        }
-        logger.warn(
-          `[${completed}/${operations.length}] ${label} \u2014 kept the baseline: ${error instanceof Error ? error.message : String(error)}
-`
-        );
-      }
-      updateSpinner();
-    }
-  };
-  const workers = Math.max(1, Math.min(options.concurrency ?? 1, operations.length));
-  for (const result of await Promise.allSettled(Array.from({ length: workers }, worker))) {
-    if (result.status === "rejected") {
-      throw result.reason;
-    }
-  }
-  if (refined === 0) {
-    throw new Error(
-      `the ${options.provider} provider did not produce a usable refinement for any operation`
-    );
-  }
-  pruneUnusedComponents(document);
-  const yaml = stringifyYaml(document);
-  await lintDocumentSource(yaml, config);
-  return { yaml, document, refined, total: operations.length };
-}
-
-// src/commands/generate-spec/components.ts
-var MIN_COMPONENT_PROPERTIES = 2;
-var MIN_DISTINCT_CONTEXTS = 2;
-var NEAR_DUPLICATE_SIMILARITY = 0.75;
-var MAX_ENVELOPE_PROPERTIES = 2;
-var NUMERIC_TYPES = /* @__PURE__ */ new Set(["integer", "number"]);
-var shapeKeyCache = /* @__PURE__ */ new WeakMap();
-function shapeKey(schema) {
-  const cached = shapeKeyCache.get(schema);
-  if (cached !== void 0) {
-    return cached;
-  }
-  let key;
-  if (schema.$ref !== void 0) {
-    key = `ref(${schema.$ref})`;
-  } else if (schema.oneOf) {
-    key = `oneOf(${schema.oneOf.map(shapeKey).sort().join("|")})`;
-  } else {
-    const type = Array.isArray(schema.type) ? [...schema.type].sort().join(",") : schema.type;
-    const parts = [`type=${type ?? ""}`];
-    if (schema.properties) {
-      const properties = Object.entries(schema.properties).map(([name, property]) => `${JSON.stringify(name)}:${shapeKey(property)}`).sort().join(",");
-      parts.push(`props{${properties}}`);
-    }
-    if (schema.additionalProperties) {
-      parts.push(`values(${shapeKey(schema.additionalProperties)})`);
-    }
-    if (schema.items) {
-      parts.push(`items(${shapeKey(schema.items)})`);
-    }
-    key = parts.join(";");
-  }
-  shapeKeyCache.set(schema, key);
-  return key;
-}
-function isExtractionCandidate(schema) {
-  return schema.$ref === void 0 && schema.type === "object" && schema.oneOf === void 0 && schema.additionalProperties === void 0 && Object.keys(schema.properties ?? {}).length >= MIN_COMPONENT_PROPERTIES;
-}
-function addVotes(votes, hints) {
-  for (const hint of hints) {
-    votes.set(hint, (votes.get(hint) ?? 0) + 1);
-  }
-}
-function collectShapes(schema, context, groups) {
-  if (schema.oneOf) {
-    schema.oneOf.forEach(
-      (member, index) => collectShapes(
-        member,
-        { ...context, path: `${context.path}/oneOf/${index}`, fallbackHints: [] },
-        groups
-      )
-    );
-    return;
-  }
-  let childContainer = context.container;
-  let childPathPrefix = `${context.path}/`;
-  if (isExtractionCandidate(schema)) {
-    const key = shapeKey(schema);
-    let group = groups.get(key);
-    if (!group) {
-      group = {
-        keys: [key],
-        schemas: [],
-        merged: {},
-        contexts: /* @__PURE__ */ new Set(),
-        primaryVotes: /* @__PURE__ */ new Map(),
-        fallbackVotes: /* @__PURE__ */ new Map()
-      };
-      groups.set(key, group);
-    }
-    group.schemas.push(schema);
-    group.contexts.add(`${context.container}#${context.path}`);
-    addVotes(group.primaryVotes, context.primaryHints);
-    addVotes(group.fallbackVotes, context.fallbackHints);
-    childContainer = key;
-    childPathPrefix = "";
-  }
-  for (const [name, property] of Object.entries(schema.properties ?? {})) {
-    collectShapes(
-      property,
-      {
-        container: childContainer,
-        path: `${childPathPrefix}${name}`,
-        primaryHints: [name],
-        fallbackHints: []
-      },
-      groups
-    );
-  }
-  if (schema.additionalProperties) {
-    collectShapes(
-      schema.additionalProperties,
-      {
-        container: childContainer,
-        path: `${childPathPrefix}additionalProperties`,
-        primaryHints: context.primaryHints.map((hint) => pluralize(hint, 1)),
-        fallbackHints: context.fallbackHints.map((hint) => pluralize(hint, 1))
-      },
-      groups
-    );
-  }
-  if (schema.items) {
-    collectShapes(
-      schema.items,
-      {
-        container: childContainer,
-        path: `${childPathPrefix}items`,
-        primaryHints: context.primaryHints.map((hint) => pluralize(hint, 1)),
-        fallbackHints: context.fallbackHints.map((hint) => pluralize(hint, 1))
-      },
-      groups
-    );
-  }
-}
-function lastStaticSegment(template) {
-  const staticSegments = template.split("/").filter((segment) => segment && !segment.startsWith("{"));
-  return staticSegments.at(-1);
-}
-function collectGroups(document) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [template, pathItem] of Object.entries(document.paths)) {
-    const entity = lastStaticSegment(template);
-    const base = entity ? pluralize(entity, 1) : void 0;
-    for (const [method, operation] of Object.entries(pathItem)) {
-      for (const [mime, media] of Object.entries(operation.requestBody?.content ?? {})) {
-        collectShapes(
-          media.schema,
-          {
-            container: `request ${method} ${template} ${mime}`,
-            path: "",
-            primaryHints: base ? [base] : [],
-            fallbackHints: base ? [`${base} request`] : []
-          },
-          groups
-        );
-      }
-      for (const [status, response] of Object.entries(operation.responses)) {
-        const isError = Number(status) >= 400;
-        for (const [mime, media] of Object.entries(response.content ?? {})) {
-          collectShapes(
-            media.schema,
-            {
-              container: `response ${method} ${template} ${status} ${mime}`,
-              path: "",
-              primaryHints: isError ? ["error"] : base ? [base] : [],
-              fallbackHints: isError ? base ? [`${base} error`] : [] : base ? [`${base} response`] : []
-            },
-            groups
-          );
-        }
-      }
-    }
-  }
-  return groups;
-}
-function propertyNames(schema) {
-  return Object.keys(schema.properties ?? {});
-}
-function nameSimilarity(a, b) {
-  const namesA = propertyNames(a);
-  const namesB = new Set(propertyNames(b));
-  const shared = namesA.filter((name) => namesB.has(name)).length;
-  const unionSize = namesA.length + namesB.size - shared;
-  return unionSize === 0 ? 0 : shared / unionSize;
-}
-function scalarTypes(schema) {
-  if (schema.$ref !== void 0 || schema.properties || schema.additionalProperties || schema.items || schema.oneOf) {
-    return void 0;
-  }
-  const types = typeof schema.type === "string" ? [schema.type] : schema.type;
-  if (!types || types.some((type) => type === "object" || type === "array")) {
-    return void 0;
-  }
-  return types;
-}
-function isUnconstrained(schema) {
-  return Object.keys(schema).length === 0;
-}
-function compatibleProperty(a, b) {
-  if (shapeKey(a) === shapeKey(b)) {
-    return true;
-  }
-  if (isUnconstrained(a) || isUnconstrained(b)) {
-    return true;
-  }
-  const scalarsA = scalarTypes(a);
-  const scalarsB = scalarTypes(b);
-  if (scalarsA && scalarsB) {
-    const typesA = new Set(scalarsA.filter((type) => type !== "null"));
-    const typesB = new Set(scalarsB.filter((type) => type !== "null"));
-    if (typesA.size === typesB.size && [...typesA].every((type) => typesB.has(type))) {
-      return true;
-    }
-    return [...typesA].every((type) => NUMERIC_TYPES.has(type)) && [...typesB].every((type) => NUMERIC_TYPES.has(type));
-  }
-  const isArrayLike = (schema) => schema.type === "array" || schema.items !== void 0;
-  if (isArrayLike(a) && isArrayLike(b)) {
-    return !a.items || !b.items || compatibleProperty(a.items, b.items);
-  }
-  return false;
-}
-function canUnify(a, b) {
-  const propertiesB = b.merged.properties ?? {};
-  return Object.entries(a.merged.properties ?? {}).every(
-    ([name, property]) => !(name in propertiesB) || compatibleProperty(property, propertiesB[name])
-  );
-}
-function unifyNearDuplicates(groups) {
-  const result = [...groups];
-  while (result.length > 1) {
-    let bestA = -1;
-    let bestB = -1;
-    let bestScore = 0;
-    for (let i = 0; i < result.length; i++) {
-      for (let j = i + 1; j < result.length; j++) {
-        const score = nameSimilarity(result[i].merged, result[j].merged);
-        if (score >= NEAR_DUPLICATE_SIMILARITY && score > bestScore && canUnify(result[i], result[j])) {
-          bestScore = score;
-          bestA = i;
-          bestB = j;
-        }
-      }
-    }
-    if (bestA === -1) {
-      break;
-    }
-    const target = result[bestA];
-    const source = result[bestB];
-    target.keys.push(...source.keys);
-    target.schemas.push(...source.schemas);
-    target.merged = mergeSchemas([target.merged, source.merged]);
-    for (const context of source.contexts) {
-      target.contexts.add(context);
-    }
-    for (const [hint, votes] of source.primaryVotes) {
-      target.primaryVotes.set(hint, (target.primaryVotes.get(hint) ?? 0) + votes);
-    }
-    for (const [hint, votes] of source.fallbackVotes) {
-      target.fallbackVotes.set(hint, (target.fallbackVotes.get(hint) ?? 0) + votes);
-    }
-    result.splice(bestB, 1);
-  }
-  return result;
-}
-function compareStrings(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function pascalCase(value) {
-  return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join("");
-}
-function rankHints(votes) {
-  return [...votes.entries()].sort(([hintA, votesA], [hintB, votesB]) => votesB - votesA || compareStrings(hintA, hintB)).map(([hint]) => hint);
-}
-function assignNames(groups) {
-  const ordered = [...groups].sort(
-    (a, b) => b.contexts.size - a.contexts.size || b.schemas.length - a.schemas.length || compareStrings(a.keys[0], b.keys[0])
-  );
-  const used = /* @__PURE__ */ new Set();
-  return ordered.map((group) => {
-    const candidates = [...rankHints(group.primaryVotes), ...rankHints(group.fallbackVotes)].map(pascalCase).filter((candidate) => candidate.length > 0);
-    if (candidates.length === 0) {
-      candidates.push("Schema");
-    }
-    let name = candidates.find((candidate) => !used.has(candidate));
-    for (let suffix = 2; name === void 0; suffix++) {
-      const numbered = `${candidates[0]}${suffix}`;
-      if (!used.has(numbered)) {
-        name = numbered;
-      }
-    }
-    used.add(name);
-    return { group, name };
-  });
-}
-function withRefs(schema, refs, isComponentRoot = false) {
-  if (!isComponentRoot) {
-    const name = refs.get(shapeKey(schema));
-    if (name !== void 0) {
-      return { $ref: `#/components/schemas/${name}` };
-    }
-  }
-  const result = { ...schema };
-  copyObservations(schema, result);
-  if (schema.properties) {
-    result.properties = Object.fromEntries(
-      Object.entries(schema.properties).map(([name, property]) => [name, withRefs(property, refs)])
-    );
-  }
-  if (schema.additionalProperties) {
-    result.additionalProperties = withRefs(schema.additionalProperties, refs);
-  }
-  if (schema.items) {
-    result.items = withRefs(schema.items, refs);
-  }
-  if (schema.oneOf) {
-    result.oneOf = schema.oneOf.map((member) => withRefs(member, refs));
-  }
-  return result;
-}
-function isUnobservedListEnvelope(schema) {
-  const properties = Object.values(schema.properties ?? {});
-  const unobservedArrays = properties.filter(
-    (property) => property.type === "array" && (!property.items || isUnconstrained(property.items))
-  );
-  return unobservedArrays.length > 0 && properties.length - unobservedArrays.length <= MAX_ENVELOPE_PROPERTIES;
-}
-function hasDominantNameHint(group) {
-  let total = 0;
-  let top = 0;
-  for (const count of group.primaryVotes.values()) {
-    total += count;
-    top = Math.max(top, count);
-  }
-  return top * 2 > total;
-}
-function extractSchemaComponents(document) {
-  const groups = collectGroups(document);
-  for (const group of groups.values()) {
-    group.merged = mergeSchemas(group.schemas);
-  }
-  const unified = unifyNearDuplicates([...groups.values()]);
-  const extracted = unified.filter(
-    (group) => group.contexts.size >= MIN_DISTINCT_CONTEXTS && (hasDominantNameHint(group) || !group.schemas.some(isUnobservedListEnvelope))
-  );
-  if (extracted.length === 0) {
-    return document;
-  }
-  const named = assignNames(extracted);
-  const refs = /* @__PURE__ */ new Map();
-  for (const { group, name } of named) {
-    for (const key of group.keys) {
-      refs.set(key, name);
-    }
-  }
-  const schemas = {};
-  for (const { group, name } of [...named].sort((a, b) => compareStrings(a.name, b.name))) {
-    schemas[name] = withRefs(group.merged, refs, true);
-  }
-  for (const pathItem of Object.values(document.paths)) {
-    for (const operation of Object.values(pathItem)) {
-      for (const media of Object.values(operation.requestBody?.content ?? {})) {
-        media.schema = withRefs(media.schema, refs);
-      }
-      for (const response of Object.values(operation.responses)) {
-        for (const media of Object.values(response.content ?? {})) {
-          media.schema = withRefs(media.schema, refs);
-        }
-      }
-    }
-  }
-  document.components = { schemas };
-  return document;
-}
-
-// src/commands/generate-spec/index.ts
-async function writeOutput(outputPath, contents) {
-  const normalized = normalizeFsPath(outputPath);
-  await mkdir(path2.dirname(normalized), { recursive: true });
-  await writeFile(normalized, contents, "utf8");
-}
-function formatElapsed(milliseconds) {
-  const totalSeconds = Math.round(milliseconds / 1e3);
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
-}
-async function handleGenerateSpec({ argv }) {
-  if (argv.type !== "openapi") {
-    return exitWithError(`Unsupported spec type "${argv.type}". Only "openapi" is supported.`);
-  }
-  const startedAt = Date.now();
-  const trafficPath = normalizeFsPath(argv.traffic);
-  const trafficFormat = argv["traffic-format"];
-  const baseline = applyValueInference(
-    extractSchemaComponents(
-      await generateSpecFromTraffic({
-        trafficPath,
-        format: trafficFormat,
-        title: argv.title,
-        server: argv.server
-      })
-    )
-  );
-  logger.info(
-    `Inferred a baseline OpenAPI description from traffic: ${countOperations(
-      baseline
-    )} operation(s).
-`
-  );
-  let resultYaml = stringifyYaml(baseline);
-  if (argv["with-ai"]) {
-    const provider = argv["ai-provider"];
-    logger.info(`Refining the description with AI provider "${provider}"...
-`);
-    logger.warn(
-      "Note: --with-ai sends samples of the recorded traffic (URLs, query strings, request and response bodies) to the selected AI provider. Make sure the traffic contains no secrets or personal data you are not allowed to share.\n"
-    );
-    const samplesByOperation = await collectTrafficSamples({
-      trafficPath,
-      format: trafficFormat,
-      server: argv.server
-    });
-    try {
-      const refined = await refineSpecWithAi({
-        provider,
-        model: argv["ai-model"],
-        baseline,
-        samplesByOperation,
-        concurrency: argv["ai-concurrency"]
-      });
-      resultYaml = refined.yaml;
-      logger.info(
-        `AI refinement complete: ${refined.refined} of ${refined.total} operation(s) refined (${provider}).
-`
-      );
-    } catch (error) {
-      logger.warn(
-        `AI refinement failed, falling back to the baseline description: ${error instanceof Error ? error.message : String(error)}
-`
-      );
-    }
-  }
-  if (argv.output) {
-    await writeOutput(argv.output, resultYaml);
-    logger.info(`Written to: ${normalizeFsPath(argv.output)}
-`);
-  } else {
-    logger.output(resultYaml);
-  }
-  logger.info(`Done in ${formatElapsed(Date.now() - startedAt)}.
-`);
-}
-export {
-  handleGenerateSpec
-};