specli 0.0.4 → 0.0.7

package/dist/cli.js

@@ -0,0 +1,2331 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/cli/runtime/argv.ts
+function getArgValue(argv, key) {
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (!a)
+      continue;
+    if (a === key)
+      return argv[i + 1];
+    if (a.startsWith(`${key}=`))
+      return a.slice(key.length + 1);
+  }
+  return;
+}
+function hasAnyArg(argv, names) {
+  return argv.some((a) => a && names.includes(a));
+}
+
+// src/cli/runtime/collect.ts
+function collectRepeatable(value, previous) {
+  return [...previous ?? [], value];
+}
+
+// src/cli/runtime/compat.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+async function readFileText(path) {
+  if (isBun) {
+    return Bun.file(path).text();
+  }
+  return readFileSync(path, "utf-8");
+}
+async function fileExists(path) {
+  if (isBun) {
+    return Bun.file(path).exists();
+  }
+  return existsSync(path);
+}
+async function writeFileText(path, content) {
+  if (isBun) {
+    await Bun.write(path, content);
+    return;
+  }
+  writeFileSync(path, content, "utf-8");
+}
+async function mkdirp(path) {
+  if (isBun) {
+    await Bun.$`mkdir -p ${path}`;
+    return;
+  }
+  mkdirSync(path, { recursive: true });
+}
+function parseYamlContent(text) {
+  if (isBun) {
+    const { YAML } = globalThis.Bun;
+    return YAML.parse(text);
+  }
+  return parseYaml(text);
+}
+async function readStdinText() {
+  if (isBun) {
+    return Bun.stdin.text();
+  }
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+var isBun;
+var init_compat = __esm(() => {
+  isBun = typeof globalThis.Bun !== "undefined";
+});
+
+// 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;
+}
+var init_auth_schemes = () => {};
+
+// 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}`;
+}
+var init_command_id = () => {};
+
+// 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;
+}
+var init_params = () => {};
+
+// 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
+  };
+}
+var init_request_body = () => {};
+
+// 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 };
+}
+var init_command_model = __esm(() => {
+  init_command_id();
+  init_params();
+  init_request_body();
+});
+
+// src/cli/pluralize.ts
+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`;
+}
+var IRREGULAR, UNCOUNTABLE;
+var init_pluralize = __esm(() => {
+  IRREGULAR = {
+    person: "people",
+    man: "men",
+    woman: "women",
+    child: "children",
+    tooth: "teeth",
+    foot: "feet",
+    mouse: "mice",
+    goose: "geese"
+  };
+  UNCOUNTABLE = new Set([
+    "metadata",
+    "information",
+    "equipment",
+    "money",
+    "series",
+    "species"
+  ]);
+});
+
+// src/cli/naming.ts
+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}`
+    };
+  });
+}
+var GENERIC_TAGS;
+var init_naming = __esm(() => {
+  init_pluralize();
+  GENERIC_TAGS = new Set(["default", "defaults", "api"]);
+});
+
+// src/cli/operations.ts
+function operationKey(method, path) {
+  return `${method.toUpperCase()} ${path}`;
+}
+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;
+}
+var HTTP_METHODS;
+var init_operations = __esm(() => {
+  HTTP_METHODS = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "options",
+    "head",
+    "trace"
+  ];
+});
+
+// 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
+  };
+}
+function toMinimalSchemaOutput(output) {
+  return {
+    schemaVersion: output.schemaVersion,
+    openapi: output.openapi,
+    spec: output.spec,
+    capabilities: output.capabilities,
+    commands: output.commands
+  };
+}
+
+// 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;
+}
+var init_server = () => {};
+
+// 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/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);
+}
+var init_spec_id = () => {};
+
+// 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
+import SwaggerParser from "@apidevtools/swagger-parser";
+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 };
+}
+var init_spec_loader = __esm(() => {
+  init_compat();
+  init_spec_id();
+});
+
+// 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
+  };
+}
+var init_context = __esm(() => {
+  init_auth_schemes();
+  init_command_model();
+  init_naming();
+  init_operations();
+  init_server();
+  init_spec_loader();
+});
+
+// src/cli/runtime/body-flags.ts
+var exports_body_flags = {};
+__export(exports_body_flags, {
+  parseDotNotationFlags: () => parseDotNotationFlags,
+  generateBodyFlags: () => generateBodyFlags,
+  findMissingRequired: () => findMissingRequired
+});
+function generateBodyFlags(schema, reservedFlags) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return [];
+  }
+  const flags = [];
+  const requiredSet = new Set(schema.required ?? []);
+  collectFlags(schema.properties, [], requiredSet, flags, reservedFlags);
+  return flags;
+}
+function collectFlags(properties, pathPrefix, requiredAtRoot, out, reservedFlags) {
+  for (const [name, propSchema] of Object.entries(properties)) {
+    if (!name || typeof name !== "string")
+      continue;
+    if (!propSchema || typeof propSchema !== "object")
+      continue;
+    const path = [...pathPrefix, name];
+    const flagName = `--${path.join(".")}`;
+    if (reservedFlags.has(flagName))
+      continue;
+    const t = propSchema.type;
+    if (t === "object" && propSchema.properties) {
+      const nestedRequired = new Set(propSchema.required ?? []);
+      collectFlags(propSchema.properties, path, nestedRequired, out, reservedFlags);
+    } else if (t === "string" || t === "number" || t === "integer" || t === "boolean") {
+      const isRequired = pathPrefix.length === 0 ? requiredAtRoot.has(name) : false;
+      out.push({
+        flag: flagName,
+        path,
+        type: t,
+        description: propSchema.description ?? `Body field '${path.join(".")}'`,
+        required: isRequired
+      });
+    }
+  }
+}
+function parseDotNotationFlags(flagValues, flagDefs) {
+  const result = {};
+  for (const def of flagDefs) {
+    const dotKey = def.path.join(".");
+    const value = flagValues[dotKey];
+    if (value === undefined)
+      continue;
+    setNestedValue(result, def.path, value, def.type);
+  }
+  return result;
+}
+function setNestedValue(obj, path, value, type) {
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const finalKey = path[path.length - 1];
+  if (type === "boolean") {
+    current[finalKey] = true;
+  } else if (type === "integer") {
+    current[finalKey] = Number.parseInt(String(value), 10);
+  } else if (type === "number") {
+    current[finalKey] = Number(String(value));
+  } else {
+    current[finalKey] = String(value);
+  }
+}
+function findMissingRequired(flagValues, flagDefs) {
+  const missing = [];
+  for (const def of flagDefs) {
+    if (!def.required)
+      continue;
+    const dotKey = def.path.join(".");
+    if (flagValues[dotKey] === undefined) {
+      missing.push(dotKey);
+    }
+  }
+  return missing;
+}
+
+// src/cli/runtime/auth/resolve.ts
+function resolveAuthScheme(authSchemes, required, inputs) {
+  if (inputs.flagAuthScheme)
+    return inputs.flagAuthScheme;
+  if (inputs.profileAuthScheme && authSchemes.some((s) => s.key === inputs.profileAuthScheme)) {
+    return inputs.profileAuthScheme;
+  }
+  if (inputs.embeddedAuthScheme && authSchemes.some((s) => s.key === inputs.embeddedAuthScheme)) {
+    return inputs.embeddedAuthScheme;
+  }
+  const alts = required.alternatives;
+  if (alts.length === 1 && alts[0]?.length === 1)
+    return alts[0][0]?.key;
+  if (authSchemes.length === 1)
+    return authSchemes[0]?.key;
+  if (inputs.hasStoredToken && alts.length > 0) {
+    for (const alt of alts) {
+      if (alt.length !== 1)
+        continue;
+      const key = alt[0]?.key;
+      const scheme = authSchemes.find((s) => s.key === key);
+      if (scheme && BEARER_COMPATIBLE_KINDS.has(scheme.kind)) {
+        return key;
+      }
+    }
+  }
+  return;
+}
+var BEARER_COMPATIBLE_KINDS;
+var init_resolve = __esm(() => {
+  BEARER_COMPATIBLE_KINDS = new Set([
+    "http-bearer",
+    "oauth2",
+    "openIdConnect"
+  ]);
+});
+
+// src/cli/runtime/profile/secrets.ts
+function secretServiceForSpec(specId) {
+  return `specli:${specId}`;
+}
+function tokenSecretKey(specId, profile) {
+  return {
+    service: secretServiceForSpec(specId),
+    name: `profile:${profile}:token`
+  };
+}
+async function setToken(specId, profile, token) {
+  if (!isBun) {
+    console.warn("Warning: Secure token storage requires Bun. Token will not be persisted.");
+    console.warn("Use --bearer-token <token> flag instead when running with Node.js.");
+    return;
+  }
+  const { secrets } = await import(bunLiteral);
+  const key = tokenSecretKey(specId, profile);
+  await secrets.set({ service: key.service, name: key.name, value: token });
+}
+async function getToken(specId, profile) {
+  if (!isBun) {
+    return null;
+  }
+  const { secrets } = await import(bunLiteral);
+  const key = tokenSecretKey(specId, profile);
+  return await secrets.get({ service: key.service, name: key.name });
+}
+async function deleteToken(specId, profile) {
+  if (!isBun) {
+    console.warn("Warning: Secure token storage requires Bun. No token to delete.");
+    return false;
+  }
+  const { secrets } = await import(bunLiteral);
+  const key = tokenSecretKey(specId, profile);
+  return await secrets.delete({ service: key.service, name: key.name });
+}
+var bunLiteral = "bun";
+var init_secrets = __esm(() => {
+  init_compat();
+});
+
+// src/cli/runtime/profile/store.ts
+function configDir() {
+  const home = process.env.HOME;
+  if (!home)
+    throw new Error("Missing HOME env var");
+  return `${home}/.config/specli`;
+}
+function configPathJson() {
+  return `${configDir()}/profiles.json`;
+}
+function configPathYaml() {
+  return `${configDir()}/profiles.yaml`;
+}
+async function readProfiles() {
+  const jsonPath = configPathJson();
+  const yamlPath = configPathYaml();
+  const jsonExists = await fileExists(jsonPath);
+  const yamlExists = await fileExists(yamlPath);
+  const filePath = jsonExists ? jsonPath : yamlExists ? yamlPath : null;
+  if (!filePath)
+    return { profiles: [] };
+  const text = await readFileText(filePath);
+  let parsed;
+  try {
+    parsed = parseYamlContent(text);
+  } catch {
+    parsed = JSON.parse(text);
+  }
+  const obj = parsed && typeof parsed === "object" ? parsed : {};
+  const profiles = Array.isArray(obj.profiles) ? obj.profiles : [];
+  return {
+    profiles: profiles.filter(Boolean),
+    defaultProfile: typeof obj.defaultProfile === "string" ? obj.defaultProfile : undefined
+  };
+}
+async function writeProfiles(data) {
+  const dir = configDir();
+  await mkdirp(dir);
+  await writeFileText(configPathJson(), JSON.stringify(data, null, 2));
+}
+function getProfile(data, name) {
+  const wanted = name ?? data.defaultProfile;
+  if (!wanted)
+    return;
+  return data.profiles.find((p) => p?.name === wanted);
+}
+function upsertProfile(data, profile) {
+  const profiles = data.profiles.filter((p) => p.name !== profile.name);
+  profiles.push(profile);
+  profiles.sort((a, b) => a.name.localeCompare(b.name));
+  return { ...data, profiles };
+}
+var init_store = __esm(() => {
+  init_compat();
+});
+
+// src/cli/runtime/template.ts
+function extractTemplateVars(template) {
+  const out = [];
+  const re = /\{([^}]+)\}/g;
+  while (true) {
+    const match = re.exec(template);
+    if (!match)
+      break;
+    out.push((match[1] ?? "").trim());
+  }
+  return out.filter(Boolean);
+}
+function applyTemplate(template, vars, options) {
+  const encode = options?.encode ?? false;
+  return template.replace(/\{([^}]+)\}/g, (_, rawName) => {
+    const name = String(rawName).trim();
+    const value = vars[name];
+    if (typeof value !== "string") {
+      throw new Error(`Missing template variable: ${name}`);
+    }
+    return encode ? encodeURIComponent(value) : value;
+  });
+}
+
+// src/cli/runtime/server-url.ts
+function resolveServerUrl(input) {
+  const base = input.serverOverride || input.servers[0]?.url;
+  if (!base) {
+    throw new Error("No server URL found. Provide --server <url> or define servers in the OpenAPI spec.");
+  }
+  const names = extractTemplateVars(base);
+  if (!names.length)
+    return base;
+  const vars = {};
+  for (const name of names) {
+    const provided = input.serverVars[name];
+    if (typeof provided === "string") {
+      vars[name] = provided;
+      continue;
+    }
+    const match = input.servers.find((s) => s.url === base);
+    const v = match?.variables.find((x) => x.name === name);
+    if (typeof v?.default === "string") {
+      vars[name] = v.default;
+      continue;
+    }
+    throw new Error(`Missing server variable '${name}'. Provide --server-var ${name}=...`);
+  }
+  return applyTemplate(base, vars);
+}
+var init_server_url = () => {};
+
+// src/cli/runtime/validate/ajv.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+function createAjv() {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    coerceTypes: false
+  });
+  addFormats(ajv);
+  return ajv;
+}
+var init_ajv = () => {};
+
+// src/cli/runtime/validate/coerce.ts
+import { InvalidArgumentError } from "commander";
+function coerceValue(raw, type) {
+  if (type === "string" || type === "unknown")
+    return raw;
+  if (type === "boolean") {
+    if (raw === "true")
+      return true;
+    if (raw === "false")
+      return false;
+    throw new InvalidArgumentError(`Expected boolean, got '${raw}'`);
+  }
+  if (type === "integer") {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n))
+      throw new InvalidArgumentError(`Expected integer, got '${raw}'`);
+    return n;
+  }
+  if (type === "number") {
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+      throw new InvalidArgumentError(`Expected number, got '${raw}'`);
+    return n;
+  }
+  if (type === "object") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new InvalidArgumentError(`Expected JSON object, got '${raw}'. Use --data/--file for complex bodies.`);
+    }
+  }
+  if (type === "array") {
+    return coerceArrayInput(raw, "string");
+  }
+  return raw;
+}
+function coerceArrayInput(raw, itemType) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return [];
+  if (trimmed.startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+    }
+    if (!Array.isArray(parsed)) {
+      throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+    }
+    return parsed.map((v) => coerceValue(String(v), itemType));
+  }
+  return trimmed.split(",").map((s) => s.trim()).filter(Boolean).map((s) => coerceValue(s, itemType));
+}
+var init_coerce = () => {};
+
+// src/cli/runtime/validate/error.ts
+function formatAjvErrors(errors) {
+  if (!errors?.length)
+    return "Invalid input";
+  return errors.map((e) => {
+    const path = e.instancePath || e.schemaPath || "";
+    if (e.keyword === "required" && e.params && typeof e.params === "object" && "missingProperty" in e.params) {
+      const missing = String(e.params.missingProperty);
+      const where = e.instancePath || "/";
+      return `${where} missing required property '${missing}'`.trim();
+    }
+    const msg = e.message || "invalid";
+    return `${path} ${msg}`.trim();
+  }).join(`
+`);
+}
+
+// src/cli/runtime/validate/schema.ts
+function deriveValidationSchemas(action) {
+  const query = { type: "object", properties: {}, required: [] };
+  const header = { type: "object", properties: {}, required: [] };
+  const cookie = { type: "object", properties: {}, required: [] };
+  for (const p of action.params) {
+    if (p.kind !== "flag")
+      continue;
+    const target = p.in === "query" ? query : p.in === "header" ? header : p.in === "cookie" ? cookie : undefined;
+    if (!target)
+      continue;
+    const schema = p.schema ?? (p.type === "unknown" ? {} : { type: p.type });
+    target.properties[p.name] = schema;
+    if (p.required) {
+      if (!target.required)
+        target.required = [];
+      target.required.push(p.name);
+    }
+  }
+  if (!query.required?.length)
+    delete query.required;
+  if (!header.required?.length)
+    delete header.required;
+  if (!cookie.required?.length)
+    delete cookie.required;
+  return {
+    querySchema: Object.keys(query.properties).length ? query : undefined,
+    headerSchema: Object.keys(header.properties).length ? header : undefined,
+    cookieSchema: Object.keys(cookie.properties).length ? cookie : undefined
+  };
+}
+
+// src/cli/runtime/validate/index.ts
+var init_validate = __esm(() => {
+  init_ajv();
+  init_coerce();
+});
+
+// src/cli/runtime/request.ts
+function parseKeyValuePairs(pairs) {
+  const out = {};
+  for (const pair of pairs ?? []) {
+    const idx = pair.indexOf("=");
+    if (idx === -1)
+      throw new Error(`Invalid pair '${pair}', expected name=value`);
+    const name = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (!name)
+      throw new Error(`Invalid pair '${pair}', missing name`);
+    out[name] = value;
+  }
+  return out;
+}
+function pickAuthSchemeKey(action, globals) {
+  if (globals.auth)
+    return globals.auth;
+  const req = action.auth.alternatives;
+  if (req.length === 1 && req[0]?.length === 1) {
+    return req[0][0]?.key;
+  }
+  return;
+}
+function applyAuth(headers, url, action, globals, authSchemes) {
+  const schemeKey = pickAuthSchemeKey(action, globals);
+  if (!schemeKey)
+    return { headers, url };
+  const scheme = authSchemes.find((s) => s.key === schemeKey);
+  if (!scheme) {
+    throw new Error(`Unknown auth scheme '${schemeKey}'. Available: ${authSchemes.map((s) => s.key).join(", ")}`);
+  }
+  if (scheme.kind === "http-bearer" || scheme.kind === "oauth2" || scheme.kind === "openIdConnect") {
+    const token = globals.bearerToken ?? globals.oauthToken;
+    if (!token)
+      throw new Error("Missing token. Provide --bearer-token <token>.");
+    headers.set("Authorization", `Bearer ${token}`);
+    return { headers, url };
+  }
+  if (scheme.kind === "http-basic") {
+    if (!globals.username)
+      throw new Error("Missing --username for basic auth");
+    if (!globals.password)
+      throw new Error("Missing --password for basic auth");
+    const raw = `${globals.username}:${globals.password}`;
+    const encoded = Buffer.from(raw, "utf8").toString("base64");
+    headers.set("Authorization", `Basic ${encoded}`);
+    return { headers, url };
+  }
+  if (scheme.kind === "api-key") {
+    if (!scheme.name)
+      throw new Error(`apiKey scheme '${scheme.key}' missing name`);
+    if (!scheme.in)
+      throw new Error(`apiKey scheme '${scheme.key}' missing location`);
+    if (!globals.apiKey)
+      throw new Error("Missing --api-key for apiKey auth");
+    if (scheme.in === "header") {
+      headers.set(scheme.name, globals.apiKey);
+    }
+    if (scheme.in === "query") {
+      url.searchParams.set(scheme.name, globals.apiKey);
+    }
+    if (scheme.in === "cookie") {
+      const existing = headers.get("Cookie");
+      const part = `${scheme.name}=${globals.apiKey}`;
+      headers.set("Cookie", existing ? `${existing}; ${part}` : part);
+    }
+    return { headers, url };
+  }
+  return { headers, url };
+}
+async function buildRequest(input) {
+  const defaultProfileName = "default";
+  const profilesFile = await readProfiles();
+  const profile = getProfile(profilesFile, defaultProfileName);
+  const embedded = input.embeddedDefaults;
+  const embeddedServerVars = parseKeyValuePairs(embedded?.serverVars);
+  const cliServerVars = parseKeyValuePairs(input.globals.serverVar);
+  const serverVars = { ...embeddedServerVars, ...cliServerVars };
+  const serverUrl = resolveServerUrl({
+    serverOverride: input.globals.server ?? profile?.server ?? embedded?.server,
+    servers: input.servers,
+    serverVars
+  });
+  const pathVars = {};
+  for (let i = 0;i < input.action.positionals.length; i++) {
+    const pos = input.action.positionals[i];
+    const raw = input.action.pathArgs[i];
+    const value = input.positionalValues[i];
+    if (typeof raw === "string" && typeof value === "string") {
+      pathVars[raw] = value;
+    }
+    if (pos?.name && typeof value === "string") {
+      pathVars[pos.name] = value;
+    }
+  }
+  const path = applyTemplate(input.action.path, pathVars, { encode: true });
+  const baseUrl = serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
+  const relativePath = path.startsWith("/") ? path.slice(1) : path;
+  const url = new URL(relativePath, baseUrl);
+  const headers = new Headers;
+  const queryValues = {};
+  const headerValues = {};
+  const cookieValues = {};
+  for (const p of input.action.params) {
+    if (p.kind !== "flag")
+      continue;
+    const optValue = input.flagValues[optionKeyFromFlag(p.flag)];
+    if (typeof optValue === "undefined")
+      continue;
+    if (p.in === "query") {
+      queryValues[p.name] = optValue;
+    }
+    if (p.in === "header") {
+      headerValues[p.name] = optValue;
+    }
+    if (p.in === "cookie") {
+      cookieValues[p.name] = optValue;
+    }
+  }
+  const schemas = deriveValidationSchemas(input.action);
+  const ajv2 = createAjv();
+  if (schemas.querySchema) {
+    const validate = ajv2.compile(schemas.querySchema);
+    if (!validate(queryValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  if (schemas.headerSchema) {
+    const validate = ajv2.compile(schemas.headerSchema);
+    if (!validate(headerValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  if (schemas.cookieSchema) {
+    const validate = ajv2.compile(schemas.cookieSchema);
+    if (!validate(cookieValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  for (const [name, value] of Object.entries(queryValues)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        url.searchParams.append(name, String(item));
+      }
+      continue;
+    }
+    url.searchParams.set(name, String(value));
+  }
+  for (const [name, value] of Object.entries(headerValues)) {
+    headers.set(name, String(value));
+  }
+  for (const [name, value] of Object.entries(cookieValues)) {
+    const existing = headers.get("Cookie");
+    const part = `${name}=${String(value)}`;
+    headers.set("Cookie", existing ? `${existing}; ${part}` : part);
+  }
+  let body;
+  if (input.action.requestBody) {
+    const bodyFlagDefs = input.bodyFlagDefs ?? [];
+    const hasBodyFlags = bodyFlagDefs.some((def) => {
+      const dotKey = def.path.join(".");
+      return input.flagValues[dotKey] !== undefined;
+    });
+    const contentType = input.action.requestBody.preferredContentType;
+    if (contentType)
+      headers.set("Content-Type", contentType);
+    const schema2 = input.action.requestBodySchema;
+    const requiredFields = bodyFlagDefs.filter((d) => d.required);
+    if (!hasBodyFlags) {
+      if (requiredFields.length > 0) {
+        const flagList = requiredFields.map((d) => `--${d.path.join(".")}`);
+        throw new Error(`Required: ${flagList.join(", ")}`);
+      }
+      if (input.action.requestBody.required) {
+        body = "{}";
+      }
+    } else {
+      if (!contentType?.includes("json")) {
+        throw new Error("Body field flags are only supported for JSON request bodies.");
+      }
+      const { findMissingRequired: findMissingRequired2, parseDotNotationFlags: parseDotNotationFlags2 } = await Promise.resolve().then(() => exports_body_flags);
+      const missing = findMissingRequired2(input.flagValues, bodyFlagDefs);
+      if (missing.length > 0) {
+        const missingFlags = missing.map((m) => `--${m}`).join(", ");
+        throw new Error(`Missing required fields: ${missingFlags}`);
+      }
+      const built = parseDotNotationFlags2(input.flagValues, bodyFlagDefs);
+      if (schema2) {
+        const validate = ajv2.compile(schema2);
+        if (!validate(built)) {
+          throw new Error(formatAjvErrors(validate.errors));
+        }
+      }
+      body = JSON.stringify(built);
+    }
+  }
+  const storedToken = profile?.name ? await getToken(input.specId, profile.name) : null;
+  const resolvedAuthScheme = resolveAuthScheme(input.authSchemes, input.action.auth, {
+    flagAuthScheme: input.globals.auth,
+    profileAuthScheme: profile?.authScheme,
+    embeddedAuthScheme: embedded?.auth,
+    hasStoredToken: Boolean(storedToken)
+  });
+  const tokenFromProfile = resolvedAuthScheme ? storedToken : null;
+  const globalsWithProfileAuth = {
+    ...input.globals,
+    auth: resolvedAuthScheme,
+    bearerToken: input.globals.bearerToken ?? input.globals.oauthToken ?? tokenFromProfile ?? undefined
+  };
+  const final = applyAuth(headers, url, input.action, globalsWithProfileAuth, input.authSchemes);
+  const req = new Request(final.url.toString(), {
+    method: input.action.method,
+    headers: final.headers,
+    body
+  });
+  const curl = buildCurl(req, body);
+  return { request: req, curl };
+}
+function buildCurl(req, body) {
+  const parts = ["curl", "-sS", "-X", req.method];
+  for (const [k, v] of req.headers.entries()) {
+    parts.push("-H", shellQuote(`${k}: ${v}`));
+  }
+  if (typeof body === "string") {
+    parts.push("--data", shellQuote(body));
+  }
+  parts.push(shellQuote(req.url));
+  return parts.join(" ");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function optionKeyFromFlag(flag) {
+  const name = flag.replace(/^--/, "");
+  return name.replace(/-([a-z])/g, (_, c) => String(c).toUpperCase());
+}
+var init_request = __esm(() => {
+  init_resolve();
+  init_secrets();
+  init_store();
+  init_server_url();
+  init_validate();
+});
+
+// src/cli/runtime/execute.ts
+function formatError(message, resourceName, actionName) {
+  const helpCmd = resourceName ? `${resourceName} ${actionName} --help` : `${actionName} --help`;
+  return `${message}
+
+Run '${helpCmd}' to see available options.`;
+}
+async function execute(input) {
+  const { request, curl } = await buildRequest({
+    specId: input.specId,
+    action: input.action,
+    positionalValues: input.positionalValues,
+    flagValues: input.flagValues,
+    globals: input.globals,
+    servers: input.servers,
+    authSchemes: input.authSchemes,
+    embeddedDefaults: input.embeddedDefaults,
+    bodyFlagDefs: input.bodyFlagDefs
+  });
+  const res = await fetch(request);
+  const contentType = res.headers.get("content-type") ?? "";
+  const text = await res.text();
+  let body = text;
+  if (contentType.includes("json") && text) {
+    try {
+      body = JSON.parse(text);
+    } catch {}
+  }
+  return {
+    ok: res.ok,
+    status: res.status,
+    body,
+    curl
+  };
+}
+async function executeAction(input) {
+  const actionName = input.action.action;
+  const resourceName = input.resourceName;
+  try {
+    if (input.globals.curl) {
+      const { curl } = await buildRequest({
+        specId: input.specId,
+        action: input.action,
+        positionalValues: input.positionalValues,
+        flagValues: input.flagValues,
+        globals: input.globals,
+        servers: input.servers,
+        authSchemes: input.authSchemes,
+        embeddedDefaults: input.embeddedDefaults,
+        bodyFlagDefs: input.bodyFlagDefs
+      });
+      process.stdout.write(`${curl}
+`);
+      return;
+    }
+    const result = await execute(input);
+    if (!result.ok) {
+      if (input.globals.json) {
+        process.stdout.write(`${JSON.stringify({ status: result.status, body: result.body })}
+`);
+      } else {
+        process.stderr.write(`HTTP ${result.status}
+`);
+        process.stderr.write(`${typeof result.body === "string" ? result.body : JSON.stringify(result.body, null, 2)}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (input.globals.json) {
+      process.stdout.write(`${JSON.stringify(result.body)}
+`);
+      return;
+    }
+    if (typeof result.body === "string") {
+      process.stdout.write(result.body);
+      if (!result.body.endsWith(`
+`))
+        process.stdout.write(`
+`);
+    } else {
+      process.stdout.write(`${JSON.stringify(result.body, null, 2)}
+`);
+    }
+  } catch (err) {
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const message = formatError(rawMessage, resourceName, actionName);
+    if (input.globals.json) {
+      process.stdout.write(`${JSON.stringify({ error: rawMessage })}
+`);
+    } else {
+      process.stderr.write(`error: ${message}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+var init_execute = __esm(() => {
+  init_request();
+});
+
+// src/cli/runtime/generated.ts
+import { Command } from "commander";
+function formatCustomHelp(cmd, action, operationFlags, bodyFlagDefs) {
+  const lines = [];
+  const cmdName = cmd.name();
+  const parentName = cmd.parent?.name() ?? "";
+  const fullCmd = parentName ? `${parentName} ${cmdName}` : cmdName;
+  const positionals = action.positionals.map((p) => `<${p.name}>`).join(" ");
+  const usageSuffix = positionals ? ` ${positionals}` : "";
+  lines.push(`Usage: ${fullCmd}${usageSuffix} [options]`);
+  lines.push("");
+  const desc = action.summary ?? action.description ?? `${action.method} ${action.path}`;
+  lines.push(desc);
+  lines.push("");
+  const requiredOpts = [];
+  const optionalOpts = [];
+  const formatOpt = (flag, type, desc2, required) => {
+    const typeStr = type === "boolean" ? "" : ` <${type}>`;
+    const reqMarker = required ? " (required)" : "";
+    return `  ${flag}${typeStr}${reqMarker}
+      ${desc2}`;
+  };
+  for (const f of operationFlags) {
+    const type = f.type === "array" ? `${f.itemType ?? "string"}[]` : f.type;
+    const line = formatOpt(f.flag, type, f.description ?? `${f.in} parameter`, f.required);
+    if (f.required) {
+      requiredOpts.push(line);
+    } else {
+      optionalOpts.push(line);
+    }
+  }
+  for (const def of bodyFlagDefs) {
+    const line = formatOpt(def.flag, def.type, def.description, def.required);
+    if (def.required) {
+      requiredOpts.push(line);
+    } else {
+      optionalOpts.push(line);
+    }
+  }
+  if (requiredOpts.length > 0) {
+    lines.push("Required:");
+    lines.push(...requiredOpts);
+    lines.push("");
+  }
+  if (optionalOpts.length > 0) {
+    lines.push("Options:");
+    lines.push(...optionalOpts);
+    lines.push("");
+  }
+  lines.push("Global:");
+  lines.push(`  --curl
+      Print curl command instead of executing`);
+  lines.push(`  --json
+      Output response as JSON`);
+  lines.push(`  --server <url>
+      Override the API server URL`);
+  lines.push(`  --bearer-token <token>
+      Provide auth token (or use 'login' command)`);
+  lines.push(`  -h, --help
+      Show this help message`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function addGeneratedCommands(program, context) {
+  for (const resource of context.commands.resources) {
+    const resourceCmd = program.command(resource.resource).description(`Operations for ${resource.resource}`);
+    for (const action of resource.actions) {
+      const cmd = resourceCmd.command(action.action);
+      cmd.description(action.summary ?? action.description ?? `${action.method} ${action.path}`);
+      for (const pos of action.positionals) {
+        cmd.argument(`<${pos.name}>`, pos.description);
+      }
+      for (const flag of action.flags) {
+        const opt = flag.flag;
+        const desc = flag.description ?? `${flag.in} parameter`;
+        if (flag.type === "boolean") {
+          cmd.option(opt, desc);
+          continue;
+        }
+        const isArray = flag.type === "array";
+        const itemType = flag.itemType ?? "string";
+        const flagType = isArray ? itemType : flag.type;
+        const parser = (raw) => coerceValue(raw, flagType);
+        if (isArray) {
+          const key2 = `${opt} <value>`;
+          cmd.option(key2, desc, (value, prev) => {
+            const next = [...prev ?? []];
+            const items = coerceArrayInput(value, itemType);
+            for (const item of items) {
+              next.push(item);
+            }
+            return next;
+          });
+          continue;
+        }
+        const key = `${opt} <value>`;
+        if (flag.required)
+          cmd.requiredOption(key, desc, parser);
+        else
+          cmd.option(key, desc, parser);
+      }
+      const operationFlagSet = new Set(action.flags.map((f) => f.flag));
+      const reservedFlags = new Set([...operationFlagSet, "--curl"]);
+      if (!operationFlagSet.has("--curl")) {
+        cmd.option("--curl", "Print curl command without sending");
+      }
+      let bodyFlagDefs = [];
+      if (action.requestBody) {
+        bodyFlagDefs = generateBodyFlags(action.requestBodySchema, reservedFlags);
+        for (const def of bodyFlagDefs) {
+          if (def.type === "boolean") {
+            cmd.option(def.flag, def.description);
+          } else {
+            cmd.option(`${def.flag} <value>`, def.description);
+          }
+        }
+      }
+      cmd.configureHelp({
+        formatHelp: () => formatCustomHelp(cmd, action, action.flags, bodyFlagDefs)
+      });
+      cmd.action(async (...args) => {
+        const command = args[args.length - 1];
+        const positionalValues = args.slice(0, -1).map((v) => String(v));
+        if (!(command instanceof Command)) {
+          throw new Error("Unexpected commander action signature");
+        }
+        const globals = command.optsWithGlobals();
+        const local = command.opts();
+        await executeAction({
+          action,
+          positionalValues,
+          flagValues: local,
+          globals,
+          servers: context.servers,
+          authSchemes: context.authSchemes,
+          specId: context.specId,
+          embeddedDefaults: context.embeddedDefaults,
+          bodyFlagDefs,
+          resourceName: resource.resource
+        });
+      });
+    }
+  }
+}
+var init_generated = __esm(() => {
+  init_execute();
+  init_validate();
+});
+
+// src/cli/main.ts
+import { Command as Command2 } from "commander";
+async function main(argv, options = {}) {
+  const program = new Command2;
+  program.name(options.cliName ?? "specli").description("Generate a CLI from an OpenAPI spec").option("--spec <urlOrPath>", "OpenAPI URL or file path").option("--server <url>", "Override server/base URL").option("--server-var <name=value>", "Server URL template variable (repeatable)", collectRepeatable).option("--auth <scheme>", "Select auth scheme by key").option("--bearer-token <token>", "Bearer token (Authorization: Bearer)").option("--oauth-token <token>", "OAuth token (alias of bearer)").option("--username <username>", "Basic auth username").option("--password <password>", "Basic auth password").option("--api-key <key>", "API key value").option("--json", "Machine-readable output").showHelpAfterError();
+  const spec = getArgValue(argv, "--spec");
+  const wantsHelp = hasAnyArg(argv, ["-h", "--help"]);
+  if (!spec && !options.embeddedSpecText && wantsHelp) {
+    program.addHelpText("after", `
+To see generated commands, run with --spec <url|path>.
+`);
+    program.parse(argv);
+    return;
+  }
+  const ctx = await buildRuntimeContext({
+    spec,
+    embeddedSpecText: options.embeddedSpecText
+  });
+  const defaultProfileName = "default";
+  program.command("login [token]").description("Store a bearer token for authentication").action(async (tokenArg, _opts, command) => {
+    const globals = command.optsWithGlobals();
+    let token = tokenArg;
+    if (!token) {
+      const isTTY = process.stdin.isTTY;
+      if (isTTY) {
+        process.stdout.write("Enter token: ");
+        const reader = process.stdin;
+        const chunks = [];
+        for await (const chunk of reader) {
+          chunks.push(chunk);
+          if (chunk.includes(10))
+            break;
+        }
+        token = Buffer.concat(chunks).toString().trim();
+      } else {
+        const text = await readStdinText();
+        token = text.trim();
+      }
+    }
+    if (!token) {
+      throw new Error("No token provided. Usage: login <token> or echo $TOKEN | login");
+    }
+    const file = await readProfiles();
+    if (!file.profiles.find((p) => p.name === defaultProfileName)) {
+      const updated = upsertProfile(file, { name: defaultProfileName });
+      await writeProfiles({ ...updated, defaultProfile: defaultProfileName });
+    } else if (!file.defaultProfile) {
+      await writeProfiles({ ...file, defaultProfile: defaultProfileName });
+    }
+    await setToken(ctx.loaded.id, defaultProfileName, token);
+    if (globals.json) {
+      process.stdout.write(`${JSON.stringify({ ok: true })}
+`);
+      return;
+    }
+    process.stdout.write(`ok: logged in
+`);
+  });
+  program.command("logout").description("Clear stored authentication token").action(async (_opts, command) => {
+    const globals = command.optsWithGlobals();
+    const deleted = await deleteToken(ctx.loaded.id, defaultProfileName);
+    if (globals.json) {
+      process.stdout.write(`${JSON.stringify({ ok: deleted })}
+`);
+      return;
+    }
+    process.stdout.write(deleted ? `ok: logged out
+` : `ok: not logged in
+`);
+  });
+  program.command("whoami").description("Show current authentication status").action(async (_opts, command) => {
+    const globals = command.optsWithGlobals();
+    const token = await getToken(ctx.loaded.id, defaultProfileName);
+    const hasToken = Boolean(token);
+    let maskedToken = null;
+    if (token && token.length > 16) {
+      maskedToken = `${token.slice(0, 8)}...${token.slice(-4)}`;
+    } else if (token) {
+      maskedToken = `${token.slice(0, 4)}...`;
+    }
+    if (globals.json) {
+      process.stdout.write(`${JSON.stringify({ authenticated: hasToken, token: maskedToken })}
+`);
+      return;
+    }
+    if (hasToken) {
+      process.stdout.write(`authenticated: yes
+`);
+      process.stdout.write(`token: ${maskedToken}
+`);
+    } else {
+      process.stdout.write(`authenticated: no
+`);
+      process.stdout.write(`Run 'login <token>' to authenticate.
+`);
+    }
+  });
+  program.command("__schema").description("Print indexed operations (machine-readable when --json)").option("--pretty", "Pretty-print JSON when used with --json").option("--min", "Minimal JSON output (commands + metadata only)").action(async (_opts, command) => {
+    const flags = command.optsWithGlobals();
+    if (flags.json) {
+      const pretty = Boolean(flags.pretty);
+      const payload = flags.min ? toMinimalSchemaOutput(ctx.schema) : ctx.schema;
+      const text = stableStringify(payload, { space: pretty ? 2 : 0 });
+      process.stdout.write(`${text}
+`);
+      return;
+    }
+    process.stdout.write(`${ctx.schema.openapi.title ?? "(untitled)"}
+`);
+    process.stdout.write(`OpenAPI: ${ctx.schema.openapi.version}
+`);
+    process.stdout.write(`Spec: ${ctx.schema.spec.id} (${ctx.schema.spec.source})
+`);
+    process.stdout.write(`Fingerprint: ${ctx.schema.spec.fingerprint}
+`);
+    process.stdout.write(`Servers: ${ctx.schema.servers.length}
+`);
+    process.stdout.write(`Auth Schemes: ${ctx.schema.authSchemes.length}
+`);
+    process.stdout.write(`Operations: ${ctx.schema.operations.length}
+`);
+    for (const op of ctx.schema.operations) {
+      const id = op.operationId ? ` (${op.operationId})` : "";
+      process.stdout.write(`- ${op.method} ${op.path}${id}
+`);
+    }
+    if (ctx.schema.planned?.length) {
+      process.stdout.write(`
+Planned commands:
+`);
+      for (const op of ctx.schema.planned) {
+        const args = op.pathArgs.length ? ` ${op.pathArgs.map((a) => `<${a}>`).join(" ")}` : "";
+        process.stdout.write(`- specli ${op.resource} ${op.action}${args}
+`);
+      }
+    }
+  });
+  addGeneratedCommands(program, {
+    servers: ctx.servers,
+    authSchemes: ctx.authSchemes,
+    commands: ctx.commands,
+    specId: ctx.loaded.id,
+    embeddedDefaults: {
+      server: options.server,
+      serverVars: options.serverVars,
+      auth: options.auth
+    }
+  });
+  await program.parseAsync(argv);
+}
+var init_main = __esm(() => {
+  init_compat();
+  init_context();
+  init_generated();
+  init_secrets();
+  init_store();
+});
+
+// src/cli/exec.ts
+var exports_exec = {};
+__export(exports_exec, {
+  execCommand: () => execCommand
+});
+async function execCommand(spec, options, commandArgs) {
+  const remainingArgs = commandArgs.slice(1);
+  const argv = [
+    process.argv[0] ?? "bun",
+    process.argv[1] ?? "specli",
+    "--spec",
+    spec
+  ];
+  if (options.server) {
+    argv.push("--server", options.server);
+  }
+  if (options.serverVar) {
+    for (const v of options.serverVar) {
+      argv.push("--server-var", v);
+    }
+  }
+  if (options.auth) {
+    argv.push("--auth", options.auth);
+  }
+  if (options.bearerToken) {
+    argv.push("--bearer-token", options.bearerToken);
+  }
+  if (options.oauthToken) {
+    argv.push("--oauth-token", options.oauthToken);
+  }
+  if (options.username) {
+    argv.push("--username", options.username);
+  }
+  if (options.password) {
+    argv.push("--password", options.password);
+  }
+  if (options.apiKey) {
+    argv.push("--api-key", options.apiKey);
+  }
+  if (options.profile) {
+    argv.push("--profile", options.profile);
+  }
+  if (options.json) {
+    argv.push("--json");
+  }
+  argv.push(...remainingArgs);
+  await main(argv);
+}
+var init_exec = __esm(() => {
+  init_main();
+});
+
+// src/cli/derive-name.ts
+async function deriveBinaryName(spec) {
+  try {
+    const text = await loadSpecText(spec);
+    const doc = parseSpec(text);
+    const title = doc?.info?.title;
+    if (title && typeof title === "string") {
+      const name = sanitizeName(title);
+      if (name)
+        return name;
+    }
+  } catch {}
+  if (/^https?:\/\//i.test(spec)) {
+    try {
+      const url = new URL(spec);
+      const hostParts = url.hostname.split(".");
+      const meaningful = hostParts.find((p) => p !== "www" && p !== "api" && p.length > 2);
+      if (meaningful) {
+        const name = sanitizeName(meaningful);
+        if (name)
+          return name;
+      }
+    } catch {}
+  }
+  return "specli";
+}
+async function loadSpecText(spec) {
+  if (/^https?:\/\//i.test(spec)) {
+    const res = await fetch(spec);
+    if (!res.ok)
+      throw new Error(`Failed to fetch: ${res.status}`);
+    return res.text();
+  }
+  return Bun.file(spec).text();
+}
+function parseSpec(text) {
+  try {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return JSON.parse(text);
+    }
+    const { YAML } = globalThis.Bun ?? {};
+    if (YAML?.parse) {
+      return YAML.parse(text);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function sanitizeName(input) {
+  let name = input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+  if (RESERVED_NAMES.includes(name)) {
+    name = `${name}-cli`;
+  }
+  return name;
+}
+var RESERVED_NAMES;
+var init_derive_name = __esm(() => {
+  RESERVED_NAMES = [
+    "exec",
+    "compile",
+    "profile",
+    "auth",
+    "help",
+    "version"
+  ];
+});
+
+// src/cli/compile.ts
+var exports_compile = {};
+__export(exports_compile, {
+  compileCommand: () => compileCommand
+});
+function parseKeyValue(input) {
+  const idx = input.indexOf("=");
+  if (idx === -1)
+    throw new Error(`Invalid --define '${input}', expected key=value`);
+  const key = input.slice(0, idx).trim();
+  const value = input.slice(idx + 1).trim();
+  if (!key)
+    throw new Error(`Invalid --define '${input}', missing key`);
+  return { key, value };
+}
+async function compileCommand(spec, options) {
+  const name = options.name ?? await deriveBinaryName(spec);
+  const outfile = options.outfile ?? `./dist/${name}`;
+  const target = options.target ? options.target : `bun-${process.platform}-${process.arch}`;
+  const define = {};
+  if (options.define) {
+    for (const pair of options.define) {
+      const { key, value } = parseKeyValue(pair);
+      define[key] = JSON.stringify(value);
+    }
+  }
+  const buildArgs = [
+    "build",
+    "--compile",
+    `--outfile=${outfile}`,
+    `--target=${target}`
+  ];
+  if (options.minify)
+    buildArgs.push("--minify");
+  if (options.bytecode)
+    buildArgs.push("--bytecode");
+  for (const [k, v] of Object.entries(define)) {
+    buildArgs.push("--define", `${k}=${v}`);
+  }
+  if (options.dotenv === false)
+    buildArgs.push("--no-compile-autoload-dotenv");
+  if (options.bunfig === false)
+    buildArgs.push("--no-compile-autoload-bunfig");
+  buildArgs.push("./src/compiled.ts");
+  const buildEnv = {
+    ...process.env,
+    SPECLI_SPEC: spec,
+    SPECLI_NAME: name
+  };
+  if (options.server)
+    buildEnv.SPECLI_SERVER = options.server;
+  if (options.serverVar?.length)
+    buildEnv.SPECLI_SERVER_VARS = options.serverVar.join(",");
+  if (options.auth)
+    buildEnv.SPECLI_AUTH = options.auth;
+  const proc = Bun.spawn({
+    cmd: ["bun", ...buildArgs],
+    stdout: "pipe",
+    stderr: "pipe",
+    env: buildEnv
+  });
+  const output = await new Response(proc.stdout).text();
+  const error2 = await new Response(proc.stderr).text();
+  const code = await proc.exited;
+  if (output)
+    process.stdout.write(output);
+  if (error2)
+    process.stderr.write(error2);
+  if (code !== 0) {
+    process.exitCode = code;
+    return;
+  }
+  process.stdout.write(`ok: built ${outfile}
+`);
+  process.stdout.write(`target: ${target}
+`);
+  process.stdout.write(`name: ${name}
+`);
+}
+var init_compile = __esm(() => {
+  init_derive_name();
+});
+
+// cli.ts
+import { Command as Command3 } from "commander";
+function collect(value, previous = []) {
+  return previous.concat([value]);
+}
+var program = new Command3;
+program.name("specli").description("Generate CLIs from OpenAPI specs");
+program.command("exec <spec>").description("Execute commands from an OpenAPI spec").option("--server <url>", "Override server/base URL").option("--server-var <name=value>", "Server variable (repeatable)", collect, []).option("--auth <scheme>", "Select auth scheme").option("--bearer-token <token>", "Bearer token").option("--oauth-token <token>", "OAuth token").option("--username <username>", "Basic auth username").option("--password <password>", "Basic auth password").option("--api-key <key>", "API key value").option("--profile <name>", "Profile name").option("--json", "Machine-readable output").allowUnknownOption().allowExcessArguments().action(async (spec, options, command) => {
+  const { execCommand: execCommand2 } = await Promise.resolve().then(() => (init_exec(), exports_exec));
+  await execCommand2(spec, options, command.args);
+});
+program.command("compile <spec>").description("Compile an OpenAPI spec into a standalone CLI binary (requires Bun)").option("--name <name>", "Binary name (default: derived from spec)").option("--outfile <path>", "Output path (default: ./dist/<name>)").option("--target <target>", "Bun compile target (e.g. bun-linux-x64)").option("--minify", "Enable minification").option("--bytecode", "Enable bytecode compilation").option("--no-dotenv", "Disable .env autoload").option("--no-bunfig", "Disable bunfig.toml autoload").option("--define <k=v>", "Build-time constant (repeatable)", collect, []).option("--server <url>", "Default server URL (embedded)").option("--server-var <k=v>", "Default server variable (repeatable, embedded)", collect, []).option("--auth <scheme>", "Default auth scheme (embedded)").action(async (spec, options) => {
+  if (typeof globalThis.Bun === "undefined") {
+    console.error("Error: The 'compile' command requires Bun.");
+    console.error("Install Bun: https://bun.sh");
+    console.error("Then run: bunx specli compile <spec>");
+    process.exit(1);
+  }
+  const { compileCommand: compileCommand2 } = await Promise.resolve().then(() => (init_compile(), exports_compile));
+  await compileCommand2(spec, options);
+});
+await program.parseAsync(process.argv);
+
+//# debugId=0B08E98087E7178B64756E2164756E21