specli 0.0.4 → 0.0.7

package/dist/src/cli/runtime/context.js

@@ -0,0 +1,936 @@
+// src/cli/strings.ts
+function kebabCase(input) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return "";
+  return trimmed.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_.:/]+/g, "-").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+
+// src/cli/auth-schemes.ts
+function parseOAuthFlow(flow) {
+  if (!flow)
+    return;
+  const scopesObj = flow.scopes;
+  const scopes = scopesObj && typeof scopesObj === "object" && !Array.isArray(scopesObj) ? Object.keys(scopesObj) : [];
+  return {
+    authorizationUrl: typeof flow.authorizationUrl === "string" ? flow.authorizationUrl : undefined,
+    tokenUrl: typeof flow.tokenUrl === "string" ? flow.tokenUrl : undefined,
+    refreshUrl: typeof flow.refreshUrl === "string" ? flow.refreshUrl : undefined,
+    scopes: scopes.sort()
+  };
+}
+function parseOAuthFlows(flows) {
+  if (!flows)
+    return;
+  const out = {};
+  const implicit = parseOAuthFlow(flows.implicit);
+  if (implicit)
+    out.implicit = implicit;
+  const password = parseOAuthFlow(flows.password);
+  if (password)
+    out.password = password;
+  const clientCredentials = parseOAuthFlow(flows.clientCredentials);
+  if (clientCredentials)
+    out.clientCredentials = clientCredentials;
+  const authorizationCode = parseOAuthFlow(flows.authorizationCode);
+  if (authorizationCode)
+    out.authorizationCode = authorizationCode;
+  return Object.keys(out).length ? out : undefined;
+}
+function listAuthSchemes(doc) {
+  const schemes = doc.components?.securitySchemes;
+  if (!schemes || typeof schemes !== "object")
+    return [];
+  const out = [];
+  for (const [key, raw] of Object.entries(schemes)) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const s = raw;
+    const type = s.type;
+    if (type === "http") {
+      const scheme = (s.scheme ?? "").toLowerCase();
+      if (scheme === "bearer") {
+        out.push({
+          key,
+          kind: "http-bearer",
+          scheme,
+          bearerFormat: s.bearerFormat,
+          description: s.description
+        });
+      } else if (scheme === "basic") {
+        out.push({
+          key,
+          kind: "http-basic",
+          scheme,
+          description: s.description
+        });
+      } else {
+        out.push({
+          key,
+          kind: "unknown",
+          scheme: s.scheme,
+          description: s.description
+        });
+      }
+      continue;
+    }
+    if (type === "apiKey") {
+      const where = s.in;
+      const loc = where === "header" || where === "query" || where === "cookie" ? where : undefined;
+      out.push({
+        key,
+        kind: "api-key",
+        name: s.name,
+        in: loc,
+        description: s.description
+      });
+      continue;
+    }
+    if (type === "oauth2") {
+      out.push({
+        key,
+        kind: "oauth2",
+        description: s.description,
+        oauthFlows: parseOAuthFlows(s.flows)
+      });
+      continue;
+    }
+    if (type === "openIdConnect") {
+      out.push({
+        key,
+        kind: "openIdConnect",
+        description: s.description,
+        openIdConnectUrl: s.openIdConnectUrl
+      });
+      continue;
+    }
+    out.push({ key, kind: "unknown", description: s.description });
+  }
+  out.sort((a, b) => kebabCase(a.key).localeCompare(kebabCase(b.key)));
+  return out;
+}
+
+// src/cli/capabilities.ts
+function uniqueSorted(items, compare) {
+  const out = [...items];
+  out.sort(compare);
+  return out.filter((v, i) => i === 0 || compare(out[i - 1], v) !== 0);
+}
+function hasSecurity(requirements) {
+  if (!requirements?.length)
+    return false;
+  return true;
+}
+function deriveCapabilities(input) {
+  const serverHasVars = input.servers.some((s) => s.variableNames.length > 0);
+  const authKinds = uniqueSorted(input.authSchemes.map((s) => s.kind), (a, b) => a.localeCompare(b));
+  const hasSecurityRequirements = hasSecurity(input.doc.security) || input.operations.some((op) => hasSecurity(op.security));
+  const opHasBodies = input.operations.some((op) => Boolean(op.requestBody));
+  const cmdResources = input.commands?.resources ?? [];
+  const cmdActions = cmdResources.flatMap((r) => r.actions);
+  const cmdHasBodies = cmdActions.some((a) => Boolean(a.requestBody));
+  return {
+    servers: {
+      count: input.servers.length,
+      hasVariables: serverHasVars
+    },
+    auth: {
+      count: input.authSchemes.length,
+      kinds: authKinds,
+      hasSecurityRequirements
+    },
+    operations: {
+      count: input.operations.length,
+      hasRequestBodies: opHasBodies
+    },
+    commands: {
+      countResources: cmdResources.length,
+      countActions: cmdActions.length,
+      hasRequestBodies: cmdHasBodies
+    }
+  };
+}
+
+// src/cli/command-index.ts
+function buildCommandsIndex(commands) {
+  const byId = {};
+  for (const resource of commands?.resources ?? []) {
+    for (const action of resource.actions) {
+      byId[action.id] = action;
+    }
+  }
+  return { byId };
+}
+
+// src/cli/auth-requirements.ts
+function isSecurityRequirement(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
+  for (const [k, v] of Object.entries(value)) {
+    if (typeof k !== "string")
+      return false;
+    if (!Array.isArray(v))
+      return false;
+    if (!v.every((s) => typeof s === "string"))
+      return false;
+  }
+  return true;
+}
+function normalizeSecurity(value) {
+  if (value == null)
+    return { requirements: [], source: "none" };
+  if (!Array.isArray(value))
+    return { requirements: [], source: "none" };
+  const reqs = value.filter(isSecurityRequirement);
+  if (reqs.length === 0)
+    return { requirements: [], source: "empty" };
+  return { requirements: reqs, source: "non-empty" };
+}
+function summarizeAuth(operationSecurity, globalSecurity, knownSchemes) {
+  const op = normalizeSecurity(operationSecurity);
+  if (op.source === "non-empty") {
+    return { alternatives: toAlternatives(op.requirements, knownSchemes) };
+  }
+  if (op.source === "empty") {
+    return { alternatives: [] };
+  }
+  const global = normalizeSecurity(globalSecurity);
+  if (global.source === "non-empty") {
+    return { alternatives: toAlternatives(global.requirements, knownSchemes) };
+  }
+  return { alternatives: [] };
+}
+function toAlternatives(requirements, knownSchemes) {
+  const known = new Set(knownSchemes.map((s) => s.key));
+  return requirements.map((req) => {
+    const out = [];
+    for (const [key, scopes] of Object.entries(req)) {
+      out.push({
+        key,
+        scopes: Array.isArray(scopes) ? scopes : []
+      });
+    }
+    out.sort((a, b) => a.key.localeCompare(b.key));
+    out.sort((a, b) => {
+      const ak = known.has(a.key) ? 0 : 1;
+      const bk = known.has(b.key) ? 0 : 1;
+      if (ak !== bk)
+        return ak - bk;
+      return a.key.localeCompare(b.key);
+    });
+    return out;
+  });
+}
+
+// src/cli/command-id.ts
+function buildCommandId(parts) {
+  const op = kebabCase(parts.operationKey.replace(/\s+/g, "-"));
+  return `${parts.specId}:${kebabCase(parts.resource)}:${kebabCase(parts.action)}:${op}`;
+}
+
+// src/cli/schema-shape.ts
+function getSchemaType(schema) {
+  if (!schema || typeof schema !== "object")
+    return "unknown";
+  const t = schema.type;
+  if (t === "string")
+    return "string";
+  if (t === "number")
+    return "number";
+  if (t === "integer")
+    return "integer";
+  if (t === "boolean")
+    return "boolean";
+  if (t === "array")
+    return "array";
+  if (t === "object")
+    return "object";
+  return "unknown";
+}
+function getSchemaFormat(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const f = schema.format;
+  return typeof f === "string" ? f : undefined;
+}
+function getSchemaEnumStrings(schema) {
+  if (!schema || typeof schema !== "object")
+    return;
+  const e = schema.enum;
+  if (!Array.isArray(e))
+    return;
+  const values = e.filter((v) => typeof v === "string");
+  return values.length ? values : undefined;
+}
+
+// src/cli/params.ts
+function deriveParamSpecs(op) {
+  const out = [];
+  for (const p of op.parameters) {
+    const flag = `--${kebabCase(p.name)}`;
+    const type = getSchemaType(p.schema);
+    const schemaObj = p.schema && typeof p.schema === "object" ? p.schema : undefined;
+    const itemsSchema = schemaObj && type === "array" && typeof schemaObj.items === "object" ? schemaObj.items : undefined;
+    out.push({
+      kind: p.in === "path" ? "positional" : "flag",
+      in: p.in,
+      name: p.name,
+      flag,
+      required: p.required,
+      description: p.description,
+      type,
+      format: getSchemaFormat(p.schema),
+      enum: getSchemaEnumStrings(p.schema),
+      itemType: type === "array" ? getSchemaType(itemsSchema) : undefined,
+      itemFormat: type === "array" ? getSchemaFormat(itemsSchema) : undefined,
+      itemEnum: type === "array" ? getSchemaEnumStrings(itemsSchema) : undefined,
+      schema: schemaObj
+    });
+  }
+  out.sort((a, b) => {
+    if (a.in !== b.in)
+      return a.in.localeCompare(b.in);
+    return a.name.localeCompare(b.name);
+  });
+  return out;
+}
+
+// src/cli/positional.ts
+function derivePositionals(action) {
+  const byName = new Map;
+  for (const name of action.pathArgs) {
+    const p = action.params.find((x) => x.in === "path" && x.name === name);
+    byName.set(name, {
+      name,
+      required: true,
+      description: p?.description,
+      type: p?.type ?? "unknown",
+      format: p?.format,
+      enum: p?.enum
+    });
+  }
+  return [...byName.values()];
+}
+function deriveFlags(action) {
+  return {
+    flags: action.params.filter((p) => p.kind === "flag").map((p) => ({
+      in: p.in,
+      name: p.name,
+      flag: p.flag,
+      required: p.required,
+      description: p.description,
+      type: p.type,
+      format: p.format,
+      enum: p.enum,
+      itemType: p.itemType,
+      itemFormat: p.itemFormat,
+      itemEnum: p.itemEnum
+    }))
+  };
+}
+
+// src/cli/types.ts
+function isJsonSchema(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/cli/request-body.ts
+function getRequestBody(op) {
+  return op.requestBody;
+}
+function deriveRequestBodyInfo(op) {
+  const rb = getRequestBody(op);
+  if (!rb)
+    return;
+  const content = [];
+  for (const contentType of rb.contentTypes) {
+    const schema = rb.schemasByContentType[contentType];
+    content.push({
+      contentType,
+      required: rb.required,
+      schemaType: getSchemaType(schema),
+      schemaFormat: getSchemaFormat(schema),
+      schemaEnum: getSchemaEnumStrings(schema)
+    });
+  }
+  content.sort((a, b) => a.contentType.localeCompare(b.contentType));
+  const hasJson = content.some((c) => c.contentType.includes("json"));
+  const hasFormUrlEncoded = content.some((c) => c.contentType === "application/x-www-form-urlencoded");
+  const hasMultipart = content.some((c) => c.contentType.startsWith("multipart/"));
+  const bodyFlags = ["--data", "--file"];
+  const preferredContentType = content.find((c) => c.contentType === "application/json")?.contentType ?? content.find((c) => c.contentType.includes("json"))?.contentType ?? content[0]?.contentType;
+  const preferredSchema = preferredContentType ? rb.schemasByContentType[preferredContentType] : undefined;
+  return {
+    required: rb.required,
+    content,
+    hasJson,
+    hasFormUrlEncoded,
+    hasMultipart,
+    bodyFlags,
+    preferredContentType,
+    preferredSchema: isJsonSchema(preferredSchema) ? preferredSchema : undefined
+  };
+}
+
+// src/cli/command-model.ts
+function buildCommandModel(planned, options) {
+  const byResource = new Map;
+  for (const op of planned) {
+    const list = byResource.get(op.resource) ?? [];
+    const params = deriveParamSpecs(op);
+    const positionals = derivePositionals({ pathArgs: op.pathArgs, params });
+    const flags = deriveFlags({ pathArgs: op.pathArgs, params });
+    list.push({
+      id: buildCommandId({
+        specId: options.specId,
+        resource: op.resource,
+        action: op.action,
+        operationKey: op.key
+      }),
+      key: op.key,
+      action: op.action,
+      pathArgs: op.pathArgs,
+      method: op.method,
+      path: op.path,
+      operationId: op.operationId,
+      tags: op.tags,
+      summary: op.summary,
+      description: op.description,
+      deprecated: op.deprecated,
+      style: op.style,
+      params,
+      positionals,
+      flags: flags.flags,
+      auth: summarizeAuth(op.security, options.globalSecurity, options.authSchemes ?? []),
+      requestBody: deriveRequestBodyInfo(op),
+      requestBodySchema: deriveRequestBodyInfo(op)?.preferredSchema
+    });
+    byResource.set(op.resource, list);
+  }
+  const resources = [];
+  for (const [resource, actions] of byResource.entries()) {
+    actions.sort((a, b) => {
+      if (a.action !== b.action)
+        return a.action.localeCompare(b.action);
+      if (a.path !== b.path)
+        return a.path.localeCompare(b.path);
+      return a.method.localeCompare(b.method);
+    });
+    resources.push({ resource, actions });
+  }
+  resources.sort((a, b) => a.resource.localeCompare(b.resource));
+  return { resources };
+}
+
+// src/cli/pluralize.ts
+var IRREGULAR = {
+  person: "people",
+  man: "men",
+  woman: "women",
+  child: "children",
+  tooth: "teeth",
+  foot: "feet",
+  mouse: "mice",
+  goose: "geese"
+};
+var UNCOUNTABLE = new Set([
+  "metadata",
+  "information",
+  "equipment",
+  "money",
+  "series",
+  "species"
+]);
+function pluralize(word) {
+  const w = word.trim();
+  if (!w)
+    return w;
+  const lower = w.toLowerCase();
+  if (UNCOUNTABLE.has(lower))
+    return lower;
+  if (IRREGULAR[lower])
+    return IRREGULAR[lower];
+  if (lower.endsWith("s"))
+    return lower;
+  if (/[bcdfghjklmnpqrstvwxyz]y$/.test(lower)) {
+    return lower.replace(/y$/, "ies");
+  }
+  if (/(ch|sh|x|z)$/.test(lower)) {
+    return `${lower}es`;
+  }
+  return `${lower}s`;
+}
+
+// src/cli/naming.ts
+var GENERIC_TAGS = new Set(["default", "defaults", "api"]);
+function getPathSegments(path) {
+  return path.split("/").map((s) => s.trim()).filter(Boolean);
+}
+function getPathArgs(path) {
+  const args = [];
+  const re = /\{([^}]+)\}/g;
+  while (true) {
+    const match = re.exec(path);
+    if (!match)
+      break;
+    args.push(match[1]);
+  }
+  return args;
+}
+function pickResourceFromTags(tags) {
+  if (!tags.length)
+    return;
+  const first = tags[0]?.trim();
+  if (!first)
+    return;
+  if (GENERIC_TAGS.has(first.toLowerCase()))
+    return;
+  return first;
+}
+function splitOperationId(operationId) {
+  const trimmed = operationId.trim();
+  if (!trimmed)
+    return {};
+  if (trimmed.includes(".")) {
+    const [prefix, ...rest] = trimmed.split(".");
+    return { prefix, suffix: rest.join(".") };
+  }
+  if (trimmed.includes("__")) {
+    const [prefix, ...rest] = trimmed.split("__");
+    return { prefix, suffix: rest.join("__") };
+  }
+  if (trimmed.includes("_")) {
+    const [prefix, ...rest] = trimmed.split("_");
+    return { prefix, suffix: rest.join("_") };
+  }
+  return { suffix: trimmed };
+}
+function inferStyle(op) {
+  if (op.path.includes("."))
+    return "rpc";
+  if (op.operationId?.includes(".") && op.method === "POST")
+    return "rpc";
+  return "rest";
+}
+function inferResource(op) {
+  const tag = pickResourceFromTags(op.tags);
+  if (tag)
+    return pluralize(kebabCase(tag));
+  if (op.operationId) {
+    const { prefix } = splitOperationId(op.operationId);
+    if (prefix) {
+      const fromId = kebabCase(prefix);
+      if (fromId === "ping")
+        return "ping";
+      return pluralize(fromId);
+    }
+  }
+  const segments = getPathSegments(op.path);
+  let first = segments[0] ?? "api";
+  first = first.includes(".") ? first.split(".")[0] : first;
+  if (first.toLowerCase() === "ping")
+    return "ping";
+  const cleaned = first.replace(/^\{.+\}$/, "");
+  return pluralize(kebabCase(cleaned || "api"));
+}
+function canonicalizeAction(action) {
+  const a = kebabCase(action);
+  if (a === "retrieve" || a === "read")
+    return "get";
+  if (a === "list" || a === "search")
+    return "list";
+  if (a === "create")
+    return "create";
+  if (a === "update" || a === "patch")
+    return "update";
+  if (a === "delete" || a === "remove")
+    return "delete";
+  return a;
+}
+function inferRestAction(op) {
+  if (op.operationId) {
+    const { suffix } = splitOperationId(op.operationId);
+    if (suffix) {
+      const fromId = canonicalizeAction(suffix);
+      if (fromId === "get" || fromId === "list" || fromId === "create" || fromId === "update" || fromId === "delete") {
+        return fromId;
+      }
+    }
+  }
+  const method = op.method.toUpperCase();
+  const args = getPathArgs(op.path);
+  const hasId = args.length > 0;
+  if (method === "GET" && !hasId)
+    return "list";
+  if (method === "POST" && !hasId)
+    return "create";
+  if (method === "GET" && hasId)
+    return "get";
+  if ((method === "PUT" || method === "PATCH") && hasId)
+    return "update";
+  if (method === "DELETE" && hasId)
+    return "delete";
+  return kebabCase(method);
+}
+function inferRpcAction(op) {
+  if (op.operationId) {
+    const { suffix } = splitOperationId(op.operationId);
+    if (suffix)
+      return canonicalizeAction(suffix);
+  }
+  const segments = getPathSegments(op.path);
+  const last = segments[segments.length - 1] ?? "";
+  if (last.includes(".")) {
+    const part = last.split(".").pop() ?? last;
+    return canonicalizeAction(part);
+  }
+  return kebabCase(op.method);
+}
+function planOperation(op) {
+  const style = inferStyle(op);
+  const resource = inferResource(op);
+  const action = style === "rpc" ? inferRpcAction(op) : inferRestAction(op);
+  return {
+    ...op,
+    key: op.key,
+    style,
+    resource,
+    action,
+    canonicalAction: action,
+    pathArgs: getPathArgs(op.path).map((a) => kebabCase(a))
+  };
+}
+function planOperations(ops) {
+  const planned = ops.map(planOperation);
+  const counts = new Map;
+  for (const op of planned) {
+    const key = `${op.resource}:${op.action}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const seen = new Map;
+  return planned.map((op) => {
+    const key = `${op.resource}:${op.action}`;
+    const total = counts.get(key) ?? 0;
+    if (total <= 1)
+      return op;
+    const idx = (seen.get(key) ?? 0) + 1;
+    seen.set(key, idx);
+    const suffix = op.operationId ? kebabCase(op.operationId) : kebabCase(`${op.method}-${op.path}`);
+    const disambiguatedAction = `${op.action}-${suffix}-${idx}`;
+    return {
+      ...op,
+      action: disambiguatedAction,
+      aliasOf: `${op.resource} ${op.canonicalAction}`
+    };
+  });
+}
+
+// src/cli/operations.ts
+function operationKey(method, path) {
+  return `${method.toUpperCase()} ${path}`;
+}
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "options",
+  "head",
+  "trace"
+];
+function normalizeParam(p) {
+  if (!p || typeof p !== "object")
+    return;
+  const loc = p.in;
+  const name = p.name;
+  if (loc !== "path" && loc !== "query" && loc !== "header" && loc !== "cookie") {
+    return;
+  }
+  if (!name)
+    return;
+  return {
+    in: loc,
+    name,
+    required: Boolean(p.required || loc === "path"),
+    description: p.description,
+    schema: p.schema
+  };
+}
+function mergeParameters(pathParams, opParams) {
+  const merged = new Map;
+  for (const p of pathParams ?? []) {
+    const normalized = normalizeParam(p);
+    if (!normalized)
+      continue;
+    merged.set(`${normalized.in}:${normalized.name}`, normalized);
+  }
+  for (const p of opParams ?? []) {
+    const normalized = normalizeParam(p);
+    if (!normalized)
+      continue;
+    merged.set(`${normalized.in}:${normalized.name}`, normalized);
+  }
+  return [...merged.values()];
+}
+function normalizeRequestBody(rb) {
+  if (!rb)
+    return;
+  const content = rb.content ?? {};
+  const contentTypes = Object.keys(content);
+  const schemasByContentType = {};
+  for (const contentType of contentTypes) {
+    schemasByContentType[contentType] = content[contentType]?.schema;
+  }
+  return {
+    required: Boolean(rb.required),
+    contentTypes,
+    schemasByContentType
+  };
+}
+function indexOperations(doc) {
+  const out = [];
+  const paths = doc.paths ?? {};
+  for (const [path, rawPathItem] of Object.entries(paths)) {
+    if (!rawPathItem || typeof rawPathItem !== "object")
+      continue;
+    const pathItem = rawPathItem;
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op)
+        continue;
+      const parameters = mergeParameters(pathItem.parameters, op.parameters);
+      const normalizedMethod = method.toUpperCase();
+      out.push({
+        key: operationKey(normalizedMethod, path),
+        method: normalizedMethod,
+        path,
+        operationId: op.operationId,
+        tags: op.tags ?? [],
+        summary: op.summary,
+        description: op.description,
+        deprecated: op.deprecated,
+        security: op.security ?? doc.security,
+        parameters,
+        requestBody: normalizeRequestBody(op.requestBody)
+      });
+    }
+  }
+  out.sort((a, b) => {
+    if (a.path !== b.path)
+      return a.path.localeCompare(b.path);
+    return a.method.localeCompare(b.method);
+  });
+  return out;
+}
+
+// src/cli/schema.ts
+function buildSchemaOutput(loaded, operations, planned, servers, authSchemes, commands, commandsIndex, capabilities) {
+  return {
+    schemaVersion: 1,
+    openapi: {
+      version: loaded.doc.openapi,
+      title: loaded.doc.info?.title,
+      infoVersion: loaded.doc.info?.version
+    },
+    spec: {
+      id: loaded.id,
+      fingerprint: loaded.fingerprint,
+      source: loaded.source
+    },
+    capabilities,
+    servers,
+    authSchemes,
+    operations,
+    planned,
+    commands,
+    commandsIndex
+  };
+}
+
+// src/cli/server.ts
+function extractVariableNames(url) {
+  const names = [];
+  const re = /\{([^}]+)\}/g;
+  while (true) {
+    const match = re.exec(url);
+    if (!match)
+      break;
+    names.push(match[1] ?? "");
+  }
+  return names.map((n) => n.trim()).filter(Boolean);
+}
+function listServers(doc) {
+  const servers = doc.servers ?? [];
+  const out = [];
+  for (const raw of servers) {
+    const s = raw;
+    if (!s || typeof s !== "object")
+      continue;
+    if (typeof s.url !== "string")
+      continue;
+    const variableNames = extractVariableNames(s.url);
+    const variables = [];
+    const rawVars = s.variables && typeof s.variables === "object" && !Array.isArray(s.variables) ? s.variables : {};
+    for (const name of variableNames) {
+      const v = rawVars[name];
+      const def = v?.default;
+      const desc = v?.description;
+      variables.push({
+        name,
+        default: typeof def === "string" ? def : undefined,
+        enum: getSchemaEnumStrings(v),
+        description: typeof desc === "string" ? desc : undefined
+      });
+    }
+    out.push({
+      url: s.url,
+      description: typeof s.description === "string" ? s.description : undefined,
+      variables,
+      variableNames
+    });
+  }
+  return out;
+}
+
+// src/cli/spec-loader.ts
+import SwaggerParser from "@apidevtools/swagger-parser";
+
+// src/cli/crypto.ts
+async function sha256Hex(text) {
+  const data = new TextEncoder().encode(text);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  const bytes = new Uint8Array(hash);
+  let out = "";
+  for (const b of bytes)
+    out += b.toString(16).padStart(2, "0");
+  return out;
+}
+
+// src/cli/runtime/compat.ts
+import { parse as parseYaml } from "yaml";
+var isBun = typeof globalThis.Bun !== "undefined";
+function parseYamlContent(text) {
+  if (isBun) {
+    const { YAML } = globalThis.Bun;
+    return YAML.parse(text);
+  }
+  return parseYaml(text);
+}
+
+// src/cli/spec-id.ts
+function getSpecId(loaded) {
+  const title = loaded.doc.info?.title;
+  const fromTitle = title ? kebabCase(title) : "";
+  if (fromTitle)
+    return fromTitle;
+  return loaded.fingerprint.slice(0, 12);
+}
+
+// src/cli/stable-json.ts
+function stableStringify(value, options) {
+  const visiting = new WeakSet;
+  return JSON.stringify(sort(value, visiting), null, options?.space);
+}
+function sort(value, visiting) {
+  if (value === null)
+    return null;
+  if (Array.isArray(value)) {
+    if (visiting.has(value))
+      return { __specli_circular: true };
+    visiting.add(value);
+    const out = value.map((v) => sort(v, visiting));
+    visiting.delete(value);
+    return out;
+  }
+  if (typeof value === "object") {
+    if (visiting.has(value))
+      return { __specli_circular: true };
+    visiting.add(value);
+    const obj = value;
+    const out = {};
+    for (const key of Object.keys(obj).sort()) {
+      out[key] = sort(obj[key], visiting);
+    }
+    visiting.delete(value);
+    return out;
+  }
+  return value;
+}
+
+// src/cli/spec-loader.ts
+function isProbablyUrl(input) {
+  return /^https?:\/\//i.test(input);
+}
+function parseSpecText(text) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return JSON.parse(text);
+  }
+  return parseYamlContent(text);
+}
+async function loadSpec(options) {
+  const { spec, embeddedSpecText } = options;
+  let source;
+  let inputForParser;
+  if (typeof embeddedSpecText === "string") {
+    source = "embedded";
+    inputForParser = parseSpecText(embeddedSpecText);
+  } else if (spec) {
+    source = isProbablyUrl(spec) ? "url" : "file";
+    inputForParser = spec;
+  } else {
+    throw new Error("Missing spec. Provide --spec <url|path> or build with an embedded spec.");
+  }
+  const doc = await SwaggerParser.dereference(inputForParser);
+  if (!doc || typeof doc !== "object" || typeof doc.openapi !== "string") {
+    throw new Error("Loaded spec is not a valid OpenAPI document");
+  }
+  const fingerprint = await sha256Hex(stableStringify(doc));
+  const id = getSpecId({ doc, fingerprint });
+  return { source, id, fingerprint, doc };
+}
+
+// src/cli/runtime/context.ts
+async function buildRuntimeContext(options) {
+  const loaded = await loadSpec({
+    spec: options.spec,
+    embeddedSpecText: options.embeddedSpecText
+  });
+  const operations = indexOperations(loaded.doc);
+  const servers = listServers(loaded.doc);
+  const authSchemes = listAuthSchemes(loaded.doc);
+  const planned = planOperations(operations);
+  const commands = buildCommandModel(planned, {
+    specId: loaded.id,
+    globalSecurity: loaded.doc.security,
+    authSchemes
+  });
+  const commandsIndex = buildCommandsIndex(commands);
+  const capabilities = deriveCapabilities({
+    doc: loaded.doc,
+    servers,
+    authSchemes,
+    operations,
+    commands
+  });
+  const schema = buildSchemaOutput(loaded, operations, planned, servers, authSchemes, commands, commandsIndex, capabilities);
+  return {
+    loaded,
+    operations,
+    servers,
+    authSchemes,
+    planned,
+    commands,
+    commandsIndex,
+    capabilities,
+    schema
+  };
+}
+export {
+  buildRuntimeContext
+};
+
+//# debugId=29AF5DFA74CC64D164756E2164756E21