@asnd/skill-creator 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,1619 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { homedir } from "os";
+import { join } from "path";
+import { parseArgs as parseArgs2 } from "util";
+
+// src/core/cache.ts
+import { createHash } from "crypto";
+import * as cacache from "cacache";
+var CACHE_IGNORED_FIELDS = /* @__PURE__ */ new Set([
+  "cacheTtl",
+  "cache_ttl",
+  "description",
+  "include",
+  "exclude",
+  "methods"
+]);
+function cacheKeyFor(config) {
+  const normalized = normalizeConfig(config);
+  return createHash("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 16);
+}
+async function loadCached(cacheDir, key, ttlSeconds) {
+  try {
+    const info = await cacache.get.info(cacheDir, key);
+    if (info === null) return null;
+    const ageSeconds = (Date.now() - info.time) / 1e3;
+    if (ageSeconds >= ttlSeconds) return null;
+    const entry = await cacache.get(cacheDir, key);
+    return JSON.parse(entry.data.toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+async function saveCache(cacheDir, key, data) {
+  await cacache.put(cacheDir, key, JSON.stringify(data));
+}
+function normalizeConfig(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (CACHE_IGNORED_FIELDS.has(key)) continue;
+    if (key === "authHeaders" || key === "auth_headers") {
+      output[key] = normalizeAuthHeaders(value);
+    } else {
+      output[key] = value;
+    }
+  }
+  return Object.fromEntries(Object.entries(output).sort(([a], [b]) => a.localeCompare(b)));
+}
+function normalizeAuthHeaders(value) {
+  if (!Array.isArray(value)) return value;
+  return [...value].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+}
+
+// src/core/coerce.ts
+import { Ajv } from "ajv";
+import addFormatsPlugin from "ajv-formats";
+var ajv = new Ajv({ allErrors: true, strict: false });
+var addFormats = addFormatsPlugin;
+addFormats(ajv);
+var validatorCache = /* @__PURE__ */ new WeakMap();
+function schemaTypeToCliType(schema) {
+  switch (schema.type) {
+    case "integer":
+      return { type: "integer", suffix: "" };
+    case "number":
+      return { type: "number", suffix: "" };
+    case "boolean":
+      return { type: "boolean", suffix: "" };
+    case "array":
+      return { type: "string", suffix: " (JSON array)" };
+    case "object":
+      return { type: "string", suffix: " (JSON object)" };
+    default:
+      return { type: "string", suffix: "" };
+  }
+}
+function coerceAndValidateValue(value, schema = {}, label = "value") {
+  const coerced = coerceValue(value, schema);
+  validateValue(coerced, schema, label);
+  return coerced;
+}
+function validateValue(value, schema = {}, label = "value") {
+  if (Object.keys(schema).length === 0) return;
+  const validate = validatorFor(schema);
+  if (validate(value)) return;
+  throw new Error(`${label} failed validation: ${formatAjvErrors(validate.errors ?? [], label)}`);
+}
+function validatorFor(schema) {
+  const cached = validatorCache.get(schema);
+  if (cached !== void 0) return cached;
+  const validate = ajv.compile(normalizeSchema(schema));
+  validatorCache.set(schema, validate);
+  return validate;
+}
+function normalizeSchema(schema) {
+  if (schema.nullable === true && typeof schema.type === "string") {
+    return { ...schema, type: [schema.type, "null"] };
+  }
+  return schema;
+}
+function formatAjvErrors(errors, label) {
+  return errors.map((error) => {
+    const path = error.instancePath.length > 0 ? `${label}${error.instancePath}` : label;
+    return `${path} ${error.message ?? "is invalid"}`;
+  }).join("; ");
+}
+function coerceValue(value, schema = {}) {
+  if (value === null || value === void 0) return null;
+  switch (schema.type) {
+    case "array":
+      return coerceArray(value, schema.items);
+    case "object":
+      return coerceObject(value);
+    case "boolean":
+      return Boolean(value);
+    case "integer":
+      return typeof value === "number" ? Math.trunc(value) : Number.parseInt(String(value), 10);
+    case "number":
+      return typeof value === "number" ? value : Number.parseFloat(String(value));
+    default:
+      return coerceSchemaless(value);
+  }
+}
+function coerceArray(value, itemSchema) {
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string") return value;
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  const values = value.includes(",") ? value.split(",").map((part) => part.trim()) : [value];
+  return values.map((item) => coerceItem(item, itemSchema?.type));
+}
+function coerceItem(value, type) {
+  switch (type) {
+    case "integer":
+      return Number.parseInt(value, 10);
+    case "number":
+      return Number.parseFloat(value);
+    case "boolean":
+      return ["true", "1", "yes"].includes(value.toLowerCase());
+    default:
+      return value;
+  }
+}
+function coerceObject(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function coerceSchemaless(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed || !["{", "["].includes(trimmed[0] ?? "")) return value;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return typeof parsed === "object" && parsed !== null ? parsed : value;
+  } catch {
+    return value;
+  }
+}
+
+// src/core/secrets.ts
+import { readFile } from "fs/promises";
+async function resolveSecret(value) {
+  if (value.startsWith("env:")) {
+    const name = value.slice(4);
+    const resolved = process.env[name];
+    if (resolved === void 0)
+      throw new Error(`environment variable ${JSON.stringify(name)} is not set`);
+    return resolved;
+  }
+  if (value.startsWith("file:")) {
+    const path = value.slice(5);
+    try {
+      return (await readFile(path, "utf8")).replace(/\n$/, "");
+    } catch {
+      throw new Error(`secret file not found: ${path}`);
+    }
+  }
+  return value;
+}
+
+// src/graphql/execute.ts
+import {
+  Kind,
+  OperationTypeNode,
+  parse,
+  print
+} from "graphql";
+import { ClientError, GraphQLClient } from "graphql-request";
+
+// src/graphql/extract.ts
+import {
+  getNamedType,
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType
+} from "graphql";
+
+// src/core/names.ts
+function toKebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+
+// src/graphql/extract.ts
+function extractGraphqlCommands(schema) {
+  const commands = [];
+  addRootFields(commands, schema.getQueryType()?.getFields(), "query");
+  addRootFields(commands, schema.getMutationType()?.getFields(), "mutation");
+  return commands;
+}
+function buildGraphqlSelectionSet(type, fields, depth = 2) {
+  if (fields !== void 0 && fields.trim().length > 0) return `{ ${fields.trim()} }`;
+  return buildDefaultSelectionSet(type, depth, /* @__PURE__ */ new Set());
+}
+function addRootFields(commands, fields, operationType) {
+  if (fields === void 0) return;
+  for (const field of Object.values(fields)) {
+    const description = optionalString(field.description);
+    commands.push({
+      name: toKebab(field.name),
+      ...description === void 0 ? {} : { description },
+      params: field.args.map(
+        (arg) => graphqlArgToParam(arg.name, arg.type, optionalString(arg.description))
+      ),
+      graphqlOperationType: operationType,
+      graphqlFieldName: field.name,
+      graphqlReturnType: field.type
+    });
+  }
+}
+function graphqlArgToParam(name, type, description) {
+  const schema = graphqlInputTypeToJsonSchema(type);
+  const cliType = schemaTypeToCliType(schema).type;
+  return {
+    name: toKebab(name),
+    originalName: name,
+    type: cliType,
+    required: isNonNullType(type),
+    ...description === void 0 ? {} : { description },
+    location: "graphql_arg",
+    schema
+  };
+}
+function graphqlInputTypeToJsonSchema(type) {
+  if (isNonNullType(type)) {
+    return { ...graphqlInputTypeToJsonSchema(type.ofType), graphqlType: graphqlTypeToString(type) };
+  }
+  if (isListType(type)) {
+    return {
+      type: "array",
+      items: graphqlInputTypeToJsonSchema(type.ofType),
+      graphqlType: graphqlTypeToString(type)
+    };
+  }
+  const namedType = getNamedType(type);
+  const base = { graphqlType: graphqlTypeToString(type) };
+  if (isEnumType(namedType)) {
+    return { ...base, type: "string", enum: namedType.getValues().map((value) => value.name) };
+  }
+  if (isInputObjectType(namedType)) return { ...base, type: "object" };
+  if (isScalarType(namedType)) {
+    switch (namedType.name) {
+      case "Int":
+        return { ...base, type: "integer" };
+      case "Float":
+        return { ...base, type: "number" };
+      case "Boolean":
+        return { ...base, type: "boolean" };
+      default:
+        return { ...base, type: "string" };
+    }
+  }
+  return { ...base, type: "string" };
+}
+function graphqlTypeToString(type) {
+  if (isNonNullType(type)) return `${graphqlTypeToString(type.ofType)}!`;
+  if (isListType(type)) return `[${graphqlTypeToString(type.ofType)}]`;
+  return getNamedType(type).name;
+}
+function optionalString(value) {
+  return value ?? void 0;
+}
+function buildDefaultSelectionSet(type, depth, seenTypes) {
+  const namedType = getNamedType(type);
+  if (isScalarType(namedType) || isEnumType(namedType)) return "";
+  if (depth <= 0) return "";
+  if (!isObjectType(namedType) && !isInterfaceType(namedType)) return "{ __typename }";
+  if (seenTypes.has(namedType.name)) return "";
+  const nextSeen = new Set(seenTypes);
+  nextSeen.add(namedType.name);
+  const selections = Object.values(namedType.getFields()).filter((field) => field.args.length === 0).map((field) => {
+    const fieldNamedType = getNamedType(field.type);
+    if (isScalarType(fieldNamedType) || isEnumType(fieldNamedType)) return field.name;
+    const nested = buildDefaultSelectionSet(field.type, depth - 1, nextSeen);
+    return nested ? `${field.name} ${nested}` : "";
+  }).filter((field) => field.length > 0);
+  return selections.length === 0 ? "" : `{ ${selections.join(" ")} }`;
+}
+
+// src/graphql/execute.ts
+async function executeGraphql(command, values, options) {
+  const fieldName = command.graphqlFieldName ?? command.name;
+  const variables = collectVariables(command, values);
+  const query = buildGraphqlOperation(
+    command,
+    fieldName,
+    variables,
+    options.fields,
+    options.selectionDepth ?? 2
+  );
+  const client = new GraphQLClient(options.endpoint, {
+    headers: Object.fromEntries(options.authHeaders ?? [])
+  });
+  try {
+    const data = await client.request(query, variables);
+    if (!isRecord(data)) return data;
+    return data[fieldName];
+  } catch (error) {
+    throw normalizeGraphqlRequestError(error);
+  }
+}
+function collectVariables(command, values) {
+  const variables = {};
+  for (const param of command.params) {
+    const value = values[param.name] ?? values[param.originalName];
+    if (value !== void 0) {
+      variables[param.originalName] = coerceAndValidateValue(
+        value,
+        param.schema ?? {},
+        `--${param.name}`
+      );
+    }
+  }
+  return variables;
+}
+function buildGraphqlOperation(command, fieldName, variables, fields, selectionDepth) {
+  const activeParams = command.params.filter(
+    (param) => param.required || variables[param.originalName] !== void 0
+  );
+  const variableDefinitions = activeParams.map(
+    (param) => ({
+      kind: Kind.VARIABLE_DEFINITION,
+      variable: {
+        kind: Kind.VARIABLE,
+        name: { kind: Kind.NAME, value: param.originalName }
+      },
+      type: parseGraphqlType(graphqlParamType(param))
+    })
+  );
+  const selectionSet = buildSelectionSetNode(command, fields, selectionDepth);
+  const field = {
+    kind: Kind.FIELD,
+    name: { kind: Kind.NAME, value: fieldName },
+    arguments: activeParams.map((param) => ({
+      kind: Kind.ARGUMENT,
+      name: { kind: Kind.NAME, value: param.originalName },
+      value: {
+        kind: Kind.VARIABLE,
+        name: { kind: Kind.NAME, value: param.originalName }
+      }
+    })),
+    ...selectionSet === void 0 ? {} : { selectionSet }
+  };
+  const operation = {
+    kind: Kind.OPERATION_DEFINITION,
+    operation: command.graphqlOperationType === "mutation" ? OperationTypeNode.MUTATION : OperationTypeNode.QUERY,
+    name: { kind: Kind.NAME, value: commandName(command) },
+    ...variableDefinitions.length === 0 ? {} : { variableDefinitions },
+    selectionSet: { kind: Kind.SELECTION_SET, selections: [field] }
+  };
+  const document = { kind: Kind.DOCUMENT, definitions: [operation] };
+  return print(document);
+}
+function buildSelectionSetNode(command, fields, selectionDepth) {
+  if (command.graphqlReturnType === void 0) return void 0;
+  const selectionSet = buildGraphqlSelectionSet(
+    command.graphqlReturnType,
+    fields,
+    selectionDepth
+  );
+  if (selectionSet.length === 0) return void 0;
+  return parseSelectionSet(selectionSet);
+}
+function parseGraphqlType(type) {
+  const operation = parseSingleOperation(`query __Type($value: ${type}) { __typename }`);
+  const variable = operation.variableDefinitions?.[0];
+  if (variable === void 0) throw new Error(`invalid GraphQL variable type: ${type}`);
+  return variable.type;
+}
+function parseSelectionSet(selectionSet) {
+  const operation = parseSingleOperation(`query __Selection { _selection ${selectionSet} }`);
+  const selection = operation.selectionSet.selections[0];
+  if (selection?.kind !== Kind.FIELD || selection.selectionSet === void 0) {
+    throw new Error("invalid GraphQL selection set");
+  }
+  return selection.selectionSet;
+}
+function parseSingleOperation(source) {
+  const document = parse(source);
+  const definition = document.definitions[0];
+  if (definition?.kind !== Kind.OPERATION_DEFINITION) {
+    throw new Error("failed to build GraphQL operation");
+  }
+  return definition;
+}
+function graphqlParamType(param) {
+  const type = param.schema?.graphqlType;
+  return typeof type === "string" ? type : jsonSchemaToGraphqlType(param.schema?.type);
+}
+function jsonSchemaToGraphqlType(type) {
+  switch (type) {
+    case "integer":
+      return "Int";
+    case "number":
+      return "Float";
+    case "boolean":
+      return "Boolean";
+    default:
+      return "String";
+  }
+}
+function commandName(command) {
+  return `${command.graphqlOperationType ?? "query"}_${command.graphqlFieldName ?? command.name}`.replace(
+    /[^_0-9A-Za-z]/g,
+    "_"
+  );
+}
+function normalizeGraphqlRequestError(error) {
+  if (error instanceof ClientError) {
+    if (error.response.errors !== void 0 && error.response.errors.length > 0) {
+      return new Error(`GraphQL error: ${formatGraphqlErrors(error.response.errors)}`);
+    }
+    return new Error(
+      `GraphQL HTTP ${error.response.status}: ${JSON.stringify(error.response, null, 0)}`
+    );
+  }
+  return error instanceof Error ? error : new Error(String(error));
+}
+function formatGraphqlErrors(errors) {
+  return errors.map((error) => error.message ?? "unknown error").join("; ");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/graphql/load.ts
+import { readFile as readFile2 } from "fs/promises";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import ky from "ky";
+import { JsonFileLoader } from "@graphql-tools/json-file-loader";
+import { loadSchema } from "@graphql-tools/load";
+import { UrlLoader } from "@graphql-tools/url-loader";
+import {
+  buildClientSchema,
+  buildSchema,
+  getIntrospectionQuery,
+  introspectionFromSchema
+} from "graphql";
+import { GraphQLClient as GraphQLClient2 } from "graphql-request";
+async function loadGraphqlSchema(endpoint, options = {}) {
+  const authHeaders = options.authHeaders ?? [];
+  if (options.schemaSource !== void 0) {
+    return loadProvidedGraphqlSchema(options.schemaSource, authHeaders);
+  }
+  const cacheKey = `graphql-${options.cacheKey ?? cacheKeyFor({ endpoint, authHeaders: options.authHeaders ?? [] })}`;
+  const ttlSeconds = options.ttlSeconds ?? 3600;
+  if (options.cacheDir !== void 0 && !options.refresh) {
+    const cached = await loadCached(options.cacheDir, cacheKey, ttlSeconds);
+    if (cached !== null) return buildClientSchema(cached);
+  }
+  try {
+    const schema = await loadRemoteGraphqlSchema(endpoint, authHeaders);
+    if (options.cacheDir !== void 0) {
+      await saveCache(options.cacheDir, cacheKey, introspectionFromSchema(schema));
+    }
+    return schema;
+  } catch (error) {
+    if (options.cacheDir !== void 0) {
+      const stale = await loadCached(
+        options.cacheDir,
+        cacheKey,
+        Number.POSITIVE_INFINITY
+      );
+      if (stale !== null) {
+        options.onWarning?.(
+          `Warning: using stale cached GraphQL schema because introspection failed: ${formatError(error)}`
+        );
+        return buildClientSchema(stale);
+      }
+    }
+    throw new Error(
+      `GraphQL introspection is disabled or unavailable. Provide a schema with --graphql-schema ./schema.graphql or --graphql-schema ./introspection.json. (${formatError(error)})`
+    );
+  }
+}
+async function loadRemoteGraphqlSchema(endpoint, authHeaders) {
+  const client = new GraphQLClient2(endpoint, {
+    headers: Object.fromEntries(authHeaders)
+  });
+  const introspection = await client.request(getIntrospectionQuery());
+  return buildClientSchema(introspection);
+}
+async function loadProvidedGraphqlSchema(source, authHeaders) {
+  try {
+    const schema = await loadSchema(source, {
+      loaders: [new UrlLoader(), new GraphQLFileLoader(), new JsonFileLoader()],
+      headers: Object.fromEntries(authHeaders)
+    });
+    return buildClientSchema(introspectionFromSchema(schema));
+  } catch {
+    return loadProvidedGraphqlSchemaFallback(source, authHeaders);
+  }
+}
+async function loadProvidedGraphqlSchemaFallback(source, authHeaders) {
+  const text = await readSchemaSource(source, authHeaders);
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    const parsed = JSON.parse(trimmed);
+    return buildClientSchema(extractIntrospection(parsed));
+  }
+  return buildSchema(text);
+}
+async function readSchemaSource(source, authHeaders) {
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const response = await ky.get(source, {
+      headers: Object.fromEntries(authHeaders),
+      throwHttpErrors: false
+    });
+    if (!response.ok) throw new Error(`failed to fetch GraphQL schema: HTTP ${response.status}`);
+    return response.text();
+  }
+  return readFile2(source, "utf8");
+}
+function extractIntrospection(value) {
+  if (!isRecord2(value)) throw new Error("GraphQL schema JSON must be an object");
+  if (isRecord2(value.data)) return extractIntrospection(value.data);
+  if (isRecord2(value.__schema)) return value;
+  throw new Error("GraphQL schema JSON must contain an introspection __schema object");
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/openapi/load.ts
+import { readFile as readFile3 } from "fs/promises";
+import ky2 from "ky";
+import YAML from "yaml";
+
+// src/openapi/refs.ts
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+async function resolveRefs(input) {
+  return await $RefParser.dereference(input, {
+    mutateInputSchema: false,
+    dereference: { circular: "ignore" }
+  });
+}
+
+// src/openapi/load.ts
+async function loadOpenApiSpec(source, options = {}) {
+  const isUrl = source.startsWith("http://") || source.startsWith("https://");
+  const ttlSeconds = options.ttlSeconds ?? 3600;
+  const key = options.cacheKey ?? cacheKeyFor({ source, authHeaders: options.authHeaders ?? [] });
+  if (isUrl && options.cacheDir !== void 0 && !options.refresh) {
+    const cached = await loadCached(options.cacheDir, key, ttlSeconds);
+    if (cached !== null) return cached;
+  }
+  const raw = isUrl ? await fetchRemoteSpec(source, options.authHeaders ?? []) : await readFile3(source, "utf8");
+  const parsed = parseSpec(raw);
+  const spec = await resolveRefs(parsed);
+  if (!isOpenApiSpec(spec)) {
+    throw new Error("spec must contain 'paths'");
+  }
+  if (isUrl && options.cacheDir !== void 0) {
+    await saveCache(options.cacheDir, key, spec);
+  }
+  return spec;
+}
+async function fetchRemoteSpec(source, authHeaders) {
+  const response = await ky2.get(source, {
+    headers: Object.fromEntries(authHeaders),
+    throwHttpErrors: false
+  });
+  if (!response.ok) throw new Error(`failed to fetch spec: HTTP ${response.status}`);
+  return response.text();
+}
+function parseSpec(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return YAML.parse(raw);
+  }
+}
+function isOpenApiSpec(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "paths" in value && typeof value.paths === "object";
+}
+
+// src/openapi/extract.ts
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "delete", "patch"]);
+function extractOpenApiCommands(spec) {
+  const commands = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  const paths = isObject(spec) && isObject(spec.paths) ? spec.paths : {};
+  for (const [path, methods] of Object.entries(paths)) {
+    if (!isObject(methods)) continue;
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!HTTP_METHODS.has(method) || !isObject(operation)) continue;
+      let name = operation.operationId !== void 0 ? toKebab(String(operation.operationId)) : fallbackName(method, path);
+      const seen = seenNames.get(name) ?? 0;
+      seenNames.set(name, seen + 1);
+      if (seen > 0) name = `${name}-${method}`;
+      const params = extractParameters(operation);
+      const body = extractRequestBodyParams(operation);
+      params.push(...body.params);
+      commands.push({
+        name,
+        description: String(
+          operation.summary ?? operation.description ?? `${method.toUpperCase()} ${path}`
+        ),
+        params,
+        hasBody: body.params.length > 0,
+        method,
+        path,
+        ...body.contentType === void 0 ? {} : { contentType: body.contentType }
+      });
+    }
+  }
+  return commands;
+}
+function extractParameters(operation) {
+  const rawParams = Array.isArray(operation.parameters) ? operation.parameters : [];
+  return rawParams.filter(isObject).map((param) => {
+    const schema = getSchema(param.schema);
+    const { type, suffix } = schemaTypeToCliType(schema);
+    const choices = Array.isArray(schema.enum) ? { choices: schema.enum } : {};
+    return {
+      name: toKebab(String(param.name)),
+      originalName: String(param.name),
+      type,
+      required: Boolean(param.required),
+      description: `${String(param.description ?? param.name)}${suffix}`,
+      ...choices,
+      location: normalizeLocation(param.in),
+      schema
+    };
+  });
+}
+function extractRequestBodyParams(operation) {
+  const requestBody = isObject(operation.requestBody) ? operation.requestBody : void 0;
+  const content = requestBody !== void 0 && isObject(requestBody.content) ? requestBody.content : {};
+  const multipartSchema = getContentSchema(content, "multipart/form-data");
+  const jsonSchema = getContentSchema(content, "application/json");
+  const multipartProps = getProperties(multipartSchema);
+  const hasBinary = Object.values(multipartProps).some((schema2) => schema2.format === "binary");
+  let schema = {};
+  let contentType;
+  if (hasBinary) {
+    schema = multipartSchema;
+    contentType = "multipart/form-data";
+  } else if (Object.keys(getProperties(jsonSchema)).length > 0) {
+    schema = jsonSchema;
+  } else if (Object.keys(multipartProps).length > 0) {
+    schema = multipartSchema;
+    contentType = "multipart/form-data";
+  }
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const properties = getProperties(schema);
+  const params = Object.entries(properties).map(([propName, propSchema]) => {
+    const isBinary = contentType === "multipart/form-data" && propSchema.format === "binary";
+    const { type, suffix } = isBinary ? { type: "string", suffix: " (file path)" } : schemaTypeToCliType(propSchema);
+    const choices = Array.isArray(propSchema.enum) ? { choices: propSchema.enum } : {};
+    return {
+      name: toKebab(propName),
+      originalName: propName,
+      type,
+      required: required.has(propName),
+      description: `${String(propSchema.description ?? propName)}${suffix}`,
+      ...choices,
+      location: isBinary ? "file" : "body",
+      schema: propSchema
+    };
+  });
+  return contentType === void 0 ? { params } : { params, contentType };
+}
+function getContentSchema(content, contentType) {
+  const item = content[contentType];
+  return isObject(item) ? getSchema(item.schema) : {};
+}
+function getProperties(schema) {
+  return isObject(schema.properties) ? Object.fromEntries(
+    Object.entries(schema.properties).filter(
+      (entry) => isObject(entry[1])
+    )
+  ) : {};
+}
+function getSchema(value) {
+  return isObject(value) ? value : {};
+}
+function normalizeLocation(value) {
+  return value === "path" || value === "header" || value === "body" || value === "file" ? value : "query";
+}
+function fallbackName(method, path) {
+  const slug = path.replace(/^\/+|\/+$/g, "").replace(/[{}]/g, "").replace(/\//g, "-");
+  return slug ? `${method}-${slug}` : method;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/openapi/execute.ts
+import ky3 from "ky";
+
+// src/openapi/params.ts
+function collectOpenApiParams(command, values, options = {}) {
+  let path = command.path ?? "";
+  const queryParams = {};
+  const headers = {};
+  let body = null;
+  const files = null;
+  for (const param of command.params) {
+    if (param.location !== "path") continue;
+    const value = values[param.name];
+    if (value !== void 0 && value !== null) {
+      path = path.replace(`{${param.originalName}}`, encodeURIComponent(String(value)));
+    }
+  }
+  for (const param of command.params) {
+    const value = values[param.name];
+    if (value === void 0 || value === null) continue;
+    if (param.location === "query") {
+      queryParams[param.originalName] = coerceAndValidateValue(
+        value,
+        param.schema ?? {},
+        `--${param.name}`
+      );
+    } else if (param.location === "header") {
+      headers[param.originalName] = String(value);
+    }
+  }
+  const method = command.method?.toLowerCase() ?? "get";
+  if (method !== "get") {
+    if (options.stdinBody !== void 0) {
+      body = options.stdinBody;
+    } else {
+      const collectedBody = {};
+      for (const param of command.params) {
+        if (param.location !== "body") continue;
+        const value = values[param.name];
+        if (value !== void 0 && value !== null) {
+          collectedBody[param.originalName] = coerceAndValidateValue(
+            value,
+            param.schema ?? {},
+            `--${param.name}`
+          );
+        }
+      }
+      body = Object.keys(collectedBody).length > 0 ? collectedBody : null;
+    }
+  }
+  return { path, queryParams, headers, body, files };
+}
+
+// src/openapi/execute.ts
+async function executeOpenApi(command, values, options) {
+  const collected = collectOpenApiParams(command, values, {
+    stdinBody: options.stdinBody
+  });
+  const url = buildUrl(options.baseUrl, collected.path, collected.queryParams);
+  const method = (command.method ?? "get").toUpperCase();
+  const headers = {
+    ...Object.fromEntries(options.authHeaders ?? []),
+    ...collected.headers
+  };
+  const body = method !== "GET" && collected.body !== null ? JSON.stringify(collected.body) : void 0;
+  if (body !== void 0) headers["Content-Type"] ??= "application/json";
+  const response = await ky3(url, {
+    method,
+    headers,
+    ...body === void 0 ? {} : { body },
+    throwHttpErrors: false
+  });
+  return {
+    status: response.status,
+    ok: response.ok,
+    text: await response.text(),
+    contentType: response.headers.get("content-type") ?? ""
+  };
+}
+function buildUrl(baseUrl, path, queryParams) {
+  const url = new URL(`${baseUrl.replace(/\/$/, "")}${path}`);
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, String(item));
+    } else {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+
+// src/mcp/extract.ts
+function extractMcpCommands(tools) {
+  return tools.map((tool) => {
+    const schema = isJsonSchema(tool.inputSchema) ? tool.inputSchema : {};
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const properties = getProperties2(schema);
+    const params = Object.entries(properties).map(([name, propSchema]) => {
+      const { type, suffix } = schemaTypeToCliType(propSchema);
+      const choices = Array.isArray(propSchema.enum) ? { choices: propSchema.enum } : {};
+      return {
+        name: toKebab(name),
+        originalName: name,
+        type,
+        required: required.has(name),
+        description: `${String(propSchema.description ?? name)}${suffix}`,
+        ...choices,
+        location: "tool_input",
+        schema: propSchema
+      };
+    });
+    return {
+      name: toKebab(tool.name),
+      description: tool.description ?? "",
+      params,
+      hasBody: params.length > 0,
+      toolName: tool.name
+    };
+  });
+}
+function getProperties2(schema) {
+  const properties = schema.properties;
+  if (typeof properties !== "object" || properties === null || Array.isArray(properties)) return {};
+  return Object.fromEntries(
+    Object.entries(properties).filter(
+      (entry) => isJsonSchema(entry[1])
+    )
+  );
+}
+function isJsonSchema(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/mcp/http.ts
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/mcp/stdio.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import stringArgv from "string-argv";
+async function listStdioTools(commandLine) {
+  return withStdioClient(commandLine, async (client) => {
+    const result = await client.listTools();
+    return result.tools.map((tool) => ({
+      name: tool.name,
+      ...tool.description === void 0 ? {} : { description: tool.description },
+      inputSchema: tool.inputSchema
+    }));
+  });
+}
+async function callStdioTool(commandLine, toolName, args) {
+  return withStdioClient(commandLine, async (client) => {
+    const result = await client.callTool({ name: toolName, arguments: args });
+    return extractMcpContent(result.content);
+  });
+}
+async function withStdioClient(commandLine, fn) {
+  const [command, ...args] = splitCommandLine(commandLine);
+  if (command === void 0) throw new Error("--mcp-stdio command cannot be empty");
+  const client = new Client({ name: "skill-creator", version: "0.1.0" });
+  const transport = new StdioClientTransport({ command, args, stderr: "pipe" });
+  await client.connect(transport);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+function splitCommandLine(commandLine) {
+  return stringArgv(commandLine);
+}
+function extractMcpContent(content) {
+  if (!Array.isArray(content)) return content;
+  const parts = content.map((part) => extractContentPart(part)).filter((part) => part !== void 0);
+  if (parts.length === 0) return "";
+  if (parts.every((part) => typeof part === "string")) return parts.join("\n");
+  return parts;
+}
+function extractContentPart(part) {
+  if (!isObject2(part)) return void 0;
+  if (part.type === "text" && typeof part.text === "string") return part.text;
+  if (typeof part.data === "string") return part.data;
+  if (part.type === "resource" && isObject2(part.resource)) {
+    if (typeof part.resource.text === "string") return part.resource.text;
+    if (typeof part.resource.blob === "string") return part.resource.blob;
+  }
+  return part;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/mcp/http.ts
+async function listHttpTools(url, optionsOrHeaders = {}) {
+  const options = normalizeOptions(optionsOrHeaders);
+  return withHttpClient(url, options, async (client) => {
+    const result = await client.listTools();
+    return result.tools.map((tool) => ({
+      name: tool.name,
+      ...tool.description === void 0 ? {} : { description: tool.description },
+      inputSchema: tool.inputSchema
+    }));
+  });
+}
+async function callHttpTool(url, toolName, args, optionsOrHeaders = {}) {
+  const options = normalizeOptions(optionsOrHeaders);
+  return withHttpClient(url, options, async (client) => {
+    const result = await client.callTool({ name: toolName, arguments: args });
+    return extractMcpContent(result.content);
+  });
+}
+async function withHttpClient(url, options, fn) {
+  if (options.transport === "auto") {
+    try {
+      return await withSingleHttpClient(url, { ...options, transport: "streamable" }, fn);
+    } catch (streamableError) {
+      try {
+        return await withSingleHttpClient(url, { ...options, transport: "sse" }, fn);
+      } catch (sseError) {
+        throw new Error(
+          `failed to connect using streamable HTTP or SSE (${formatError2(streamableError)}; ${formatError2(sseError)})`
+        );
+      }
+    }
+  }
+  return withSingleHttpClient(url, options, fn);
+}
+async function withSingleHttpClient(url, options, fn) {
+  const client = new Client2({ name: "skill-creator", version: "0.1.0" });
+  const transport = createTransport(url, options);
+  await client.connect(transport);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+function createTransport(url, options) {
+  const headers = Object.fromEntries(options.headers);
+  if (options.transport === "sse") {
+    const fetchWithHeaders = (input, init) => fetch(input, { ...init, headers: { ...headers, ...headersToObject(init?.headers) } });
+    return new SSEClientTransport(new URL(url), {
+      eventSourceInit: { fetch: fetchWithHeaders },
+      requestInit: { headers }
+    });
+  }
+  return new StreamableHTTPClientTransport(new URL(url), {
+    requestInit: { headers }
+  });
+}
+function normalizeOptions(optionsOrHeaders) {
+  if (Array.isArray(optionsOrHeaders)) {
+    return { headers: optionsOrHeaders, transport: "auto" };
+  }
+  return {
+    headers: optionsOrHeaders.headers ?? [],
+    transport: optionsOrHeaders.transport ?? "auto"
+  };
+}
+function headersToObject(headers) {
+  if (headers === void 0) return {};
+  return Object.fromEntries(new Headers(headers).entries());
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli/dynamic.ts
+import { parseArgs } from "util";
+
+// src/core/filter.ts
+import { minimatch } from "minimatch";
+function filterCommands(commands, filters = {}) {
+  let result = commands;
+  if (filters.methods?.length) {
+    const allowed = new Set(filters.methods.map((method) => method.toUpperCase()));
+    result = result.filter(
+      (command) => command.method === void 0 || allowed.has(command.method.toUpperCase())
+    );
+  }
+  if (filters.include?.length) {
+    result = result.filter(
+      (command) => filters.include?.some((pattern) => minimatch(command.name, pattern)) ?? false
+    );
+  }
+  if (filters.exclude?.length) {
+    result = result.filter(
+      (command) => !(filters.exclude?.some((pattern) => minimatch(command.name, pattern)) ?? false)
+    );
+  }
+  return result;
+}
+
+// src/core/output.ts
+function applyHead(data, n) {
+  if (Array.isArray(data)) return data.slice(0, n);
+  return data;
+}
+function formatOutput(data, options = {}) {
+  if (options.raw) {
+    return {
+      stdout: `${typeof data === "string" ? data : JSON.stringify(data)}
+`,
+      stderr: ""
+    };
+  }
+  let value = parseJsonStringIfPossible(data);
+  if (options.head !== void 0) value = applyHead(value, options.head);
+  if (typeof value === "string") {
+    return { stdout: `${value}
+`, stderr: "" };
+  }
+  return {
+    stdout: `${JSON.stringify(value, null, options.pretty ? 2 : 0)}
+`,
+    stderr: ""
+  };
+}
+function parseJsonStringIfPossible(data) {
+  if (typeof data !== "string") return data;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+}
+
+// src/cli/dynamic.ts
+async function runDynamicMode(options) {
+  let commands = filterCommands(await options.loadCommands(), options.globals);
+  if (options.globals.search !== void 0) {
+    commands = searchCommands(commands, options.globals.search);
+  }
+  if (options.globals.list || options.globals.search !== void 0) {
+    writeStdout(options.renderCommands(commands));
+    return;
+  }
+  if (options.commandArgv.length === 0) {
+    if (options.onEmptyCommand !== void 0) {
+      await options.onEmptyCommand(commands);
+      return;
+    }
+    writeStdout(options.renderCommands(commands));
+    return;
+  }
+  const commandName2 = options.commandArgv[0];
+  if (commandName2 === void 0) throw new Error("missing subcommand");
+  const command = commands.find((candidate) => candidate.name === commandName2);
+  if (command === void 0) throw new Error(`unknown subcommand: ${commandName2}`);
+  if (options.commandArgv.includes("--help") || options.commandArgv.includes("-h")) {
+    writeStdout(renderCommandHelp(command));
+    return;
+  }
+  const prepared = await prepareCommandArgs(options, options.commandArgv.slice(1));
+  const values = parseCommandValues(command, prepared.argv, prepared.initialValues ?? {});
+  const result = await options.executeCommand(command, values, prepared.argv);
+  writeFormattedOutput(result, options.globals);
+}
+function searchCommands(commands, search) {
+  const pattern = search.toLowerCase();
+  return commands.filter(
+    (command) => command.name.toLowerCase().includes(pattern) || (command.description ?? "").toLowerCase().includes(pattern)
+  );
+}
+async function prepareCommandArgs(options, argv) {
+  return options.prepareCommandArgs === void 0 ? { argv } : await options.prepareCommandArgs(argv);
+}
+function parseCommandValues(command, argv, initialValues = {}) {
+  const values = { ...initialValues };
+  const params = new Map(command.params.map((param) => [param.name, param]));
+  validateCommandOptions(command, argv, params);
+  const { values: parsedValues } = parseArgs({
+    args: normalizeStringOptionValues(argv, stringParamNames(command)),
+    options: commandOptionSpec(command),
+    strict: true,
+    allowPositionals: true
+  });
+  for (const param of command.params) {
+    const value = parsedValues[param.name];
+    if (value !== void 0) values[param.name] = value;
+  }
+  for (const param of command.params) {
+    if (param.required && values[param.name] === void 0 && values[param.originalName] === void 0 && param.location !== "body") {
+      throw new Error(`missing required option --${param.name}`);
+    }
+  }
+  return values;
+}
+function validateCommandOptions(command, argv, params) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === void 0 || !token.startsWith("--")) continue;
+    const rawFlag = token.slice(2);
+    const flag = rawFlag.includes("=") ? rawFlag.slice(0, rawFlag.indexOf("=")) : rawFlag;
+    const param = params.get(flag);
+    if (param === void 0) throw new Error(`unknown option for ${command.name}: --${flag}`);
+    if (param.type !== "boolean" && !rawFlag.includes("=") && argv[index + 1] === void 0) {
+      throw new Error(`missing value for --${flag}`);
+    }
+  }
+}
+function commandOptionSpec(command) {
+  return Object.fromEntries(
+    command.params.map((param) => [
+      param.name,
+      { type: param.type === "boolean" ? "boolean" : "string" }
+    ])
+  );
+}
+function stringParamNames(command) {
+  return new Set(
+    command.params.filter((param) => param.type !== "boolean").map((param) => param.name)
+  );
+}
+function normalizeStringOptionValues(argv, optionNames) {
+  const result = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const next = argv[index + 1];
+    if (token !== void 0 && next !== void 0 && token.startsWith("--") && !token.includes("=") && optionNames.has(token.slice(2)) && next.startsWith("-")) {
+      result.push(`${token}=${next}`);
+      index += 1;
+    } else if (token !== void 0) {
+      result.push(token);
+    }
+  }
+  return result;
+}
+function renderCommandHelp(command) {
+  const lines = [`${command.name}: ${command.description ?? ""}`, "", "Options:"];
+  for (const param of command.params) {
+    const required = param.required ? " (required)" : "";
+    lines.push(
+      `  --${param.name.padEnd(24)} ${param.description ?? param.originalName}${required}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function writeFormattedOutput(data, globals) {
+  const output = formatOutput(data, {
+    pretty: globals.pretty,
+    raw: globals.raw,
+    ...globals.head === void 0 ? {} : { head: globals.head }
+  });
+  if (output.stderr) console.error(output.stderr.replace(/\n$/, ""));
+  writeStdout(output.stdout);
+}
+function writeStdout(text) {
+  console.log(text.replace(/\n$/, ""));
+}
+
+// src/cli/parse.ts
+function splitAtSubcommand(argv, spec) {
+  const valueOptions = new Set(spec.valueOptions);
+  const boolOptions = new Set(spec.boolOptions);
+  let index = 0;
+  while (index < argv.length) {
+    const arg = argv[index];
+    if (arg === void 0) break;
+    if (arg === "--") {
+      return {
+        globalArgv: argv.slice(0, index),
+        commandArgv: argv.slice(index + 1)
+      };
+    }
+    if (arg.startsWith("-")) {
+      const optionName = arg.startsWith("--") && arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg;
+      if (arg.startsWith("--") && arg.includes("=")) {
+        index += 1;
+      } else if (valueOptions.has(optionName)) {
+        index += 2;
+      } else if (boolOptions.has(optionName)) {
+        index += 1;
+      } else {
+        index += 1;
+      }
+      continue;
+    }
+    return {
+      globalArgv: argv.slice(0, index),
+      commandArgv: argv.slice(index)
+    };
+  }
+  return { globalArgv: argv, commandArgv: [] };
+}
+
+// src/cli/main.ts
+var GLOBAL_OPTION_SPEC = {
+  valueOptions: [
+    "--spec",
+    "--mcp",
+    "--mcp-stdio",
+    "--graphql",
+    "--graphql-schema",
+    "--base-url",
+    "--auth-header",
+    "--transport",
+    "--cache-key",
+    "--cache-ttl",
+    "--search",
+    "--include",
+    "--exclude",
+    "--methods",
+    "--fields",
+    "--selection-depth",
+    "--head"
+  ],
+  boolOptions: ["--list", "--pretty", "--raw", "--refresh", "--stdin", "--version", "--help", "-h"]
+};
+async function run(argv = process.argv.slice(2)) {
+  if (argv[0] === "--") argv = argv.slice(1);
+  const { globalArgv, commandArgv } = splitAtSubcommand(argv, GLOBAL_OPTION_SPEC);
+  const globals = parseGlobalArgs(globalArgv);
+  if (globals.version) {
+    const pkg = await import("./package-4Q4VX3O2.js");
+    writeStdout2(`skill-creator ${pkg.default.version}
+`);
+    return 0;
+  }
+  if (globals.help && commandArgv.length === 0) {
+    printHelp();
+    return 0;
+  }
+  try {
+    validateSourceModes(globals);
+    globals.authHeaders = await resolveAuthHeaders(globals.authHeaders);
+    if (globals.spec !== void 0) {
+      await handleOpenApiMode(globals, commandArgv);
+      return 0;
+    }
+    if (globals.mcpStdio !== void 0) {
+      await handleMcpStdioMode(globals, commandArgv);
+      return 0;
+    }
+    if (globals.mcp !== void 0) {
+      await handleMcpHttpMode(globals, commandArgv);
+      return 0;
+    }
+    if (globals.graphql !== void 0) {
+      await handleGraphqlMode(globals, commandArgv);
+      return 0;
+    }
+    console.error(
+      "Error: only --spec, --mcp-stdio, --mcp, and --graphql modes are implemented in this TypeScript port so far."
+    );
+    return 1;
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+}
+async function handleOpenApiMode(globals, commandArgv) {
+  if (globals.spec === void 0) throw new Error("--spec is required");
+  const source = globals.spec;
+  const spec = await loadOpenApiSpec(source, {
+    authHeaders: globals.authHeaders,
+    cacheDir: defaultCacheDir(),
+    ...globals.cacheKey === void 0 ? {} : { cacheKey: globals.cacheKey },
+    ttlSeconds: globals.cacheTtl,
+    refresh: globals.refresh
+  });
+  await runDynamicMode({
+    globals,
+    commandArgv,
+    loadCommands: () => extractOpenApiCommands(spec),
+    renderCommands: renderOpenApiCommands,
+    onEmptyCommand: () => {
+      printHelp();
+      throw new Error("provide a subcommand, or use --list to see available commands");
+    },
+    executeCommand: async (command, values) => {
+      const baseUrl = determineBaseUrl(spec, source, globals.baseUrl);
+      const response = await executeOpenApi(command, values, {
+        baseUrl,
+        authHeaders: globals.authHeaders
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.text}`);
+      return response.text;
+    }
+  });
+}
+async function handleGraphqlMode(globals, commandArgv) {
+  if (globals.graphql === void 0) throw new Error("--graphql is required");
+  const endpoint = globals.graphql;
+  const schema = await loadGraphqlSchema(endpoint, {
+    authHeaders: globals.authHeaders,
+    cacheDir: defaultCacheDir(),
+    ...globals.cacheKey === void 0 ? {} : { cacheKey: globals.cacheKey },
+    ttlSeconds: globals.cacheTtl,
+    refresh: globals.refresh,
+    ...globals.graphqlSchema === void 0 ? {} : { schemaSource: globals.graphqlSchema },
+    onWarning: (message) => console.error(message)
+  });
+  await runDynamicMode({
+    globals,
+    commandArgv,
+    loadCommands: () => extractGraphqlCommands(schema),
+    renderCommands: renderGraphqlCommands,
+    prepareCommandArgs: async (argv) => {
+      const stdinFlag = stripFlag(argv, "--stdin");
+      const stdinValues = globals.stdin || stdinFlag.enabled ? await readStdinJson() : {};
+      return { argv: stdinFlag.argv, initialValues: stdinValues };
+    },
+    executeCommand: (command, values) => executeGraphql(command, values, {
+      endpoint,
+      authHeaders: globals.authHeaders,
+      ...globals.fields === void 0 ? {} : { fields: globals.fields },
+      selectionDepth: globals.selectionDepth
+    })
+  });
+}
+async function handleMcpHttpMode(globals, commandArgv) {
+  if (globals.mcp === void 0) throw new Error("--mcp is required");
+  const endpoint = globals.mcp;
+  await runDynamicMode({
+    globals,
+    commandArgv,
+    loadCommands: async () => extractMcpCommands(await loadMcpHttpTools(globals)),
+    renderCommands: renderMcpCommands,
+    executeCommand: async (command, values) => {
+      const toolArgs = collectMcpToolArgs(command, values);
+      return callHttpTool(endpoint, command.toolName ?? command.name, toolArgs, {
+        headers: globals.authHeaders,
+        transport: globals.transport
+      });
+    }
+  });
+}
+async function loadMcpHttpTools(globals) {
+  if (globals.mcp === void 0) throw new Error("--mcp is required");
+  const cacheKey = `mcp-${globals.cacheKey ?? cacheKeyFor({
+    source: globals.mcp,
+    authHeaders: globals.authHeaders,
+    transport: globals.transport
+  })}`;
+  const cacheDir = defaultCacheDir();
+  if (!globals.refresh) {
+    const cached = await loadCached(cacheDir, cacheKey, globals.cacheTtl);
+    if (cached !== null) return cached;
+  }
+  const tools = await listHttpTools(globals.mcp, {
+    headers: globals.authHeaders,
+    transport: globals.transport
+  });
+  await saveCache(cacheDir, cacheKey, tools);
+  return tools;
+}
+async function handleMcpStdioMode(globals, commandArgv) {
+  if (globals.mcpStdio === void 0) throw new Error("--mcp-stdio is required");
+  const commandLine = globals.mcpStdio;
+  await runDynamicMode({
+    globals,
+    commandArgv,
+    loadCommands: async () => extractMcpCommands(await listStdioTools(commandLine)),
+    renderCommands: renderMcpCommands,
+    executeCommand: async (command, values) => {
+      const toolArgs = collectMcpToolArgs(command, values);
+      return callStdioTool(commandLine, command.toolName ?? command.name, toolArgs);
+    }
+  });
+}
+function collectMcpToolArgs(command, values) {
+  const args = {};
+  for (const param of command.params) {
+    if (values[param.name] !== void 0) {
+      args[param.originalName] = coerceAndValidateValue(
+        values[param.name],
+        param.schema ?? {},
+        `--${param.name}`
+      );
+    }
+  }
+  return args;
+}
+function parseGlobalArgs(argv) {
+  assertKnownValueOptionsHaveValues(argv, GLOBAL_OPTION_SPEC.valueOptions);
+  const { values } = parseArgs2({
+    args: argv,
+    options: {
+      spec: { type: "string" },
+      mcp: { type: "string" },
+      "mcp-stdio": { type: "string" },
+      graphql: { type: "string" },
+      "graphql-schema": { type: "string" },
+      "base-url": { type: "string" },
+      "auth-header": { type: "string", multiple: true },
+      transport: { type: "string" },
+      "cache-key": { type: "string" },
+      "cache-ttl": { type: "string" },
+      search: { type: "string" },
+      include: { type: "string" },
+      exclude: { type: "string" },
+      methods: { type: "string" },
+      fields: { type: "string" },
+      "selection-depth": { type: "string" },
+      head: { type: "string" },
+      list: { type: "boolean" },
+      pretty: { type: "boolean" },
+      raw: { type: "boolean" },
+      refresh: { type: "boolean" },
+      stdin: { type: "boolean" },
+      version: { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    strict: false,
+    allowPositionals: false
+  });
+  const authHeaders = stringListOption(values["auth-header"]).map(parseHeader);
+  const search = stringOption(values.search);
+  return {
+    ...optionalStringProperty("spec", stringOption(values.spec)),
+    ...optionalStringProperty("mcp", stringOption(values.mcp)),
+    ...optionalStringProperty("mcpStdio", stringOption(values["mcp-stdio"])),
+    ...optionalStringProperty("graphql", stringOption(values.graphql)),
+    ...optionalStringProperty("graphqlSchema", stringOption(values["graphql-schema"])),
+    ...optionalStringProperty("baseUrl", stringOption(values["base-url"])),
+    authHeaders,
+    transport: parseTransport(stringOption(values.transport) ?? "auto"),
+    ...optionalStringProperty("cacheKey", stringOption(values["cache-key"])),
+    cacheTtl: Number.parseInt(stringOption(values["cache-ttl"]) ?? "3600", 10),
+    refresh: values.refresh === true,
+    list: values.list === true || search !== void 0,
+    ...optionalStringProperty("search", search),
+    ...optionalStringArrayProperty("include", parseOptionalCommaList(values.include)),
+    ...optionalStringArrayProperty("exclude", parseOptionalCommaList(values.exclude)),
+    ...optionalStringArrayProperty("methods", parseOptionalCommaList(values.methods)),
+    ...optionalStringProperty("fields", stringOption(values.fields)),
+    selectionDepth: Number.parseInt(stringOption(values["selection-depth"]) ?? "2", 10),
+    stdin: values.stdin === true,
+    pretty: values.pretty === true,
+    raw: values.raw === true,
+    ...optionalNumberProperty("head", parseOptionalInteger(values.head)),
+    help: values.help === true,
+    version: values.version === true
+  };
+}
+function renderOpenApiCommands(commands) {
+  if (commands.length === 0) return "No commands found.\n";
+  return `${commands.map(
+    (command) => `${command.name.padEnd(32)} ${(command.method ?? "").toUpperCase().padEnd(6)} ${command.description ?? ""}`.trimEnd()
+  ).join("\n")}
+`;
+}
+function renderMcpCommands(commands) {
+  if (commands.length === 0) return "No tools found.\n";
+  return `${commands.map((command) => `${command.name.padEnd(32)} ${command.description ?? ""}`.trimEnd()).join("\n")}
+`;
+}
+function renderGraphqlCommands(commands) {
+  if (commands.length === 0) return "No GraphQL operations found.\n";
+  return `${commands.map(
+    (command) => `${command.name.padEnd(32)} ${(command.graphqlOperationType ?? "").padEnd(8)} ${command.description ?? ""}`.trimEnd()
+  ).join("\n")}
+`;
+}
+function determineBaseUrl(spec, source, override) {
+  if (override !== void 0) return override;
+  const servers = Array.isArray(spec.servers) ? spec.servers : [];
+  const firstServer = servers[0];
+  const serverUrl = typeof firstServer === "object" && firstServer !== null && "url" in firstServer ? String(firstServer.url) : "";
+  if (serverUrl.startsWith("http://") || serverUrl.startsWith("https://")) return serverUrl;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    const origin = new URL(source).origin;
+    return serverUrl ? `${origin}${serverUrl}` : origin;
+  }
+  throw new Error("cannot determine base URL. Use --base-url.");
+}
+function validateSourceModes(globals) {
+  const active = [globals.spec, globals.mcp, globals.mcpStdio, globals.graphql].filter(
+    (value) => value !== void 0
+  ).length;
+  if (active === 0) {
+    printHelp();
+    throw new Error("one of --spec, --mcp, --mcp-stdio, or --graphql is required.");
+  }
+  if (active > 1)
+    throw new Error("--spec, --mcp, --mcp-stdio, and --graphql are mutually exclusive.");
+}
+function assertKnownValueOptionsHaveValues(argv, options) {
+  const valueOptions = new Set(options);
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === void 0 || !token.startsWith("--")) continue;
+    const option = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+    if (!valueOptions.has(option) || token.includes("=")) continue;
+    if (argv[index + 1] === void 0) throw new Error(`missing value for ${option}`);
+  }
+}
+function stringOption(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function stringListOption(value) {
+  if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
+  const single = stringOption(value);
+  return single === void 0 ? [] : [single];
+}
+function optionalStringProperty(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function optionalStringArrayProperty(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function optionalNumberProperty(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function parseOptionalCommaList(value) {
+  const raw = stringOption(value);
+  return raw === void 0 ? void 0 : parseCommaList(raw);
+}
+function parseOptionalInteger(value) {
+  const raw = stringOption(value);
+  return raw === void 0 ? void 0 : Number.parseInt(raw, 10);
+}
+function stripFlag(argv, flag) {
+  let enabled = false;
+  const filtered = argv.filter((token) => {
+    if (token !== flag) return true;
+    enabled = true;
+    return false;
+  });
+  return { argv: filtered, enabled };
+}
+async function readStdinJson() {
+  let raw = "";
+  for await (const chunk of process.stdin) raw += String(chunk);
+  if (raw.trim().length === 0) return {};
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("--stdin must contain a JSON object");
+  }
+  return parsed;
+}
+function parseCommaList(value) {
+  return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function parseTransport(value) {
+  if (value === "auto" || value === "streamable" || value === "sse") return value;
+  throw new Error("--transport must be one of: auto, streamable, sse");
+}
+function parseHeader(header) {
+  const colon = header.indexOf(":");
+  if (colon === -1) throw new Error(`invalid auth header format: ${header}`);
+  return [header.slice(0, colon).trim(), header.slice(colon + 1).trim()];
+}
+async function resolveAuthHeaders(headers) {
+  return Promise.all(headers.map(async ([key, value]) => [key, await resolveSecret(value)]));
+}
+function defaultCacheDir() {
+  return process.env.SKILL_CREATOR_CACHE_DIR ?? join(homedir(), ".cache", "skill-creator");
+}
+function printHelp() {
+  writeStdout2(`skill-creator [global options] <subcommand> [command options]
+
+Source (mutually exclusive, one required):
+  --spec URL|FILE       OpenAPI spec (JSON or YAML, local or remote)
+  --mcp URL             MCP server URL (HTTP/SSE)
+  --mcp-stdio CMD       MCP server command (stdio transport)
+  --graphql URL         GraphQL endpoint URL
+
+Options:
+  --auth-header K:V     HTTP header (repeatable)
+  --transport TYPE      MCP HTTP transport: auto|streamable|sse (default: auto)
+  --base-url URL        Override base URL from spec
+  --graphql-schema SRC  GraphQL SDL or introspection JSON schema FILE|URL
+  --cache-key KEY       Custom cache key
+  --cache-ttl SECONDS   Cache TTL (default: 3600)
+  --refresh             Bypass cache
+  --list                List available subcommands
+  --search PATTERN      Search commands by name or description
+  --include GLOBS       Include command globs (comma-separated)
+  --exclude GLOBS       Exclude command globs (comma-separated)
+  --methods METHODS     OpenAPI method filter, e.g. GET,POST
+  --fields FIELDS       Override GraphQL selection set
+  --selection-depth N   GraphQL default selection depth (default: 2)
+  --stdin               Read GraphQL variables from stdin JSON
+  --pretty              Pretty-print JSON output
+  --raw                 Print raw response body
+  --head N              Limit output to first N array records
+  --help, -h            Show help
+  --version             Show version
+`);
+}
+function writeStdout2(text) {
+  console.log(text.replace(/\n$/, ""));
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const code = await run();
+  process.exitCode = code;
+}
+export {
+  run
+};
+//# sourceMappingURL=main.js.map