@asnd/skill-creator 0.1.2 → 0.1.3

package/dist/cli/main.js

@@ -1,1583 +1,431 @@
 #!/usr/bin/env node
-
-// src/cli/main.ts
-import { realpathSync } from "fs";
-import { homedir } from "os";
-import { join, resolve } from "path";
-import { fileURLToPath } from "url";
-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);
-      }
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { runInstallCommand } from '../commands/install.js';
+import { cacheKeyFor, loadCached, saveCache } from '../core/cache.js';
+import { coerceAndValidateValue } from '../core/coerce.js';
+import { resolveSecret } from '../core/secrets.js';
+import { executeGraphql } from '../graphql/execute.js';
+import { extractGraphqlCommands } from '../graphql/extract.js';
+import { loadGraphqlSchema } from '../graphql/load.js';
+import { extractMcpCommands } from '../mcp/extract.js';
+import { callHttpTool, listHttpTools } from '../mcp/http.js';
+import { callStdioTool, listStdioTools } from '../mcp/stdio.js';
+import { executeOpenApi } from '../openapi/execute.js';
+import { extractOpenApiCommands } from '../openapi/extract.js';
+import { loadOpenApiSpec } from '../openapi/load.js';
+import { runGenerate } from '../skills/generate.js';
+import { runDynamicMode } from './dynamic.js';
+import { splitAtSubcommand } from './parse.js';
+const 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'],
+};
+export async function run(argv = process.argv.slice(2)) {
+    if (argv[0] === '--')
+        argv = argv.slice(1);
+    if (argv[0] === 'generate') {
+        try {
+            await runGenerate(argv.slice(1));
+            return 0;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            return 1;
+        }
     }
-    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 }
-      });
+    if (argv[0] === 'command' || argv[0] === 'commands' || argv[0] === 'install-command') {
+        try {
+            await runInstallCommand(argv.slice(1));
+            return 0;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            return 1;
+        }
     }
-  }
-  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)));
+    const { globalArgv, commandArgv } = splitAtSubcommand(argv, GLOBAL_OPTION_SPEC);
+    const globals = parseGlobalArgs(globalArgv);
+    if (globals.version) {
+        const pkg = await import('../../package.json', { with: { type: 'json' } });
+        writeStdout(`skill-creator ${pkg.default.version}\n`);
+        return 0;
     }
-  }
-  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);
+    if (globals.help && commandArgv.length === 0) {
+        printHelp();
+        return 0;
     }
-  }
-  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}`
-          );
+    try {
+        validateSourceModes(globals);
+        globals.authHeaders = await resolveAuthHeaders(globals.authHeaders);
+        if (globals.spec !== undefined) {
+            await handleOpenApiMode(globals, commandArgv);
+            return 0;
         }
-      }
-      body = Object.keys(collectedBody).length > 0 ? collectedBody : null;
+        if (globals.mcpStdio !== undefined) {
+            await handleMcpStdioMode(globals, commandArgv);
+            return 0;
+        }
+        if (globals.mcp !== undefined) {
+            await handleMcpHttpMode(globals, commandArgv);
+            return 0;
+        }
+        if (globals.graphql !== undefined) {
+            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;
     }
-  }
-  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));
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
     }
-  }
-  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
-      };
+async function handleOpenApiMode(globals, commandArgv) {
+    if (globals.spec === undefined)
+        throw new Error('--spec is required');
+    const source = globals.spec;
+    const spec = await loadOpenApiSpec(source, {
+        authHeaders: globals.authHeaders,
+        cacheDir: defaultCacheDir(),
+        ...(globals.cacheKey === undefined ? {} : { cacheKey: globals.cacheKey }),
+        ttlSeconds: globals.cacheTtl,
+        refresh: globals.refresh,
     });
-    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 }
+    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;
+        },
     });
-  }
-  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-SLCRJ4QY.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
-    })
-  });
+    if (globals.graphql === undefined)
+        throw new Error('--graphql is required');
+    const endpoint = globals.graphql;
+    const schema = await loadGraphqlSchema(endpoint, {
+        authHeaders: globals.authHeaders,
+        cacheDir: defaultCacheDir(),
+        ...(globals.cacheKey === undefined ? {} : { cacheKey: globals.cacheKey }),
+        ttlSeconds: globals.cacheTtl,
+        refresh: globals.refresh,
+        ...(globals.graphqlSchema === undefined ? {} : { 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 === undefined ? {} : { 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
-      });
-    }
-  });
+    if (globals.mcp === undefined)
+        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;
+    if (globals.mcp === undefined)
+        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);
-    }
-  });
+    if (globals.mcpStdio === undefined)
+        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}`
-      );
+    const args = {};
+    for (const param of command.params) {
+        if (values[param.name] !== undefined) {
+            args[param.originalName] = coerceAndValidateValue(values[param.name], param.schema ?? {}, `--${param.name}`);
+        }
     }
-  }
-  return args;
+    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
-  };
+    assertKnownValueOptionsHaveValues(argv, GLOBAL_OPTION_SPEC.valueOptions);
+    const { values } = parseArgs({
+        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 !== undefined,
+        ...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")}
-`;
+    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')}\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")}
-`;
+    if (commands.length === 0)
+        return 'No tools found.\n';
+    return `${commands
+        .map((command) => `${command.name.padEnd(32)} ${command.description ?? ''}`.trimEnd())
+        .join('\n')}\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")}
-`;
+    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')}\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.");
+    if (override !== undefined)
+        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.");
+    const active = [globals.spec, globals.mcp, globals.mcpStdio, globals.graphql].filter((value) => value !== undefined).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}`);
-  }
+    const valueOptions = new Set(options);
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === undefined || !token.startsWith('--'))
+            continue;
+        const option = token.includes('=') ? token.slice(0, token.indexOf('=')) : token;
+        if (!valueOptions.has(option) || token.includes('='))
+            continue;
+        if (argv[index + 1] === undefined)
+            throw new Error(`missing value for ${option}`);
+    }
 }
 function stringOption(value) {
-  return typeof value === "string" ? value : void 0;
+    return typeof value === 'string' ? value : undefined;
 }
 function stringListOption(value) {
-  if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
-  const single = stringOption(value);
-  return single === void 0 ? [] : [single];
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === 'string');
+    const single = stringOption(value);
+    return single === undefined ? [] : [single];
 }
 function optionalStringProperty(key, value) {
-  return value === void 0 ? {} : { [key]: value };
+    return value === undefined ? {} : { [key]: value };
 }
 function optionalStringArrayProperty(key, value) {
-  return value === void 0 ? {} : { [key]: value };
+    return value === undefined ? {} : { [key]: value };
 }
 function optionalNumberProperty(key, value) {
-  return value === void 0 ? {} : { [key]: value };
+    return value === undefined ? {} : { [key]: value };
 }
 function parseOptionalCommaList(value) {
-  const raw = stringOption(value);
-  return raw === void 0 ? void 0 : parseCommaList(raw);
+    const raw = stringOption(value);
+    return raw === undefined ? undefined : parseCommaList(raw);
 }
 function parseOptionalInteger(value) {
-  const raw = stringOption(value);
-  return raw === void 0 ? void 0 : Number.parseInt(raw, 10);
+    const raw = stringOption(value);
+    return raw === undefined ? undefined : 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 };
+    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;
+    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);
+    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");
+    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()];
+    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)]));
+    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");
+    return process.env.SKILL_CREATOR_CACHE_DIR ?? join(homedir(), '.cache', 'skill-creator');
 }
 function printHelp() {
-  writeStdout2(`skill-creator [global options] <subcommand> [command options]
+    writeStdout(`npx @asnd/skill-creator [global options] <subcommand> [command options]
+npx @asnd/skill-creator generate --template openapi --name NAME --spec URL|FILE --agent AGENT --scope project|global
+npx @asnd/skill-creator command install --agent AGENT --scope project|global
 
 Source (mutually exclusive, one required):
   --spec URL|FILE       OpenAPI spec (JSON or YAML, local or remote)
@@ -1608,24 +456,22 @@ Options:
   --version             Show version
 `);
 }
-function writeStdout2(text) {
-  console.log(text.replace(/\n$/, ""));
+function writeStdout(text) {
+    console.log(text.replace(/\n$/, ''));
 }
-function isCliEntrypoint(metaUrl, argv1 = process.argv[1]) {
-  if (!argv1) return false;
-  const modulePath = fileURLToPath(metaUrl);
-  try {
-    return realpathSync(argv1) === realpathSync(modulePath);
-  } catch {
-    return resolve(argv1) === modulePath;
-  }
+export function isCliEntrypoint(metaUrl, argv1 = process.argv[1]) {
+    if (!argv1)
+        return false;
+    const modulePath = fileURLToPath(metaUrl);
+    try {
+        return realpathSync(argv1) === realpathSync(modulePath);
+    }
+    catch {
+        return resolve(argv1) === modulePath;
+    }
 }
 if (isCliEntrypoint(import.meta.url)) {
-  const code = await run();
-  process.exitCode = code;
+    const code = await run();
+    process.exitCode = code;
 }
-export {
-  isCliEntrypoint,
-  run
-};
 //# sourceMappingURL=main.js.map