hostctl 0.1.55 → 0.1.57

package/dist/index.js

@@ -2719,7 +2719,7 @@ var Verbosity = {
 };
 
 // src/version.ts
-var version = "0.1.55";
+var version = "0.1.57";
 
 // src/commands/pkg/create.ts
 import { promises as fs5 } from "fs";
@@ -31924,8 +31924,8 @@ function renderTaskRows(rows, {
       name: r.name,
       description: r.description,
       module: r.module,
-      inputSchema: Boolean(r.inputSchema),
-      outputSchema: Boolean(r.outputSchema),
+      inputSchema: schemaToDescriptor(r.inputSchema),
+      outputSchema: schemaToDescriptor(r.outputSchema),
       schemaSource: r.schemaSource
     }));
     console.log(JSON.stringify(sanitized, null, 2));
@@ -31966,9 +31966,12 @@ function summarizeType(val) {
     case "optional":
     case "ZodNullable":
     case "nullable":
+    case "ZodDefault":
+    case "default":
       return summarizeType(def.innerType || def.type);
     case "ZodEffects":
-      return summarizeType(def.schema);
+    case "pipe":
+      return summarizeType(def.schema || def.in);
     case "ZodString":
     case "string":
       return { type: "string", desc };
@@ -31991,8 +31994,11 @@ function summarizeType(val) {
       return types.length ? { type: types.join(" | "), desc } : {};
     }
     case "ZodLiteral":
-    case "literal":
-      return { type: JSON.stringify(def.value), desc };
+    case "literal": {
+      const values3 = Array.isArray(def?.values) ? def.values : def?.value !== void 0 ? [def.value] : [];
+      const value = values3.length ? values3[0] : void 0;
+      return { type: value !== void 0 ? JSON.stringify(value) : void 0, desc };
+    }
     case "ZodObject":
     case "object":
       return { type: "object", desc };
@@ -32000,6 +32006,140 @@ function summarizeType(val) {
       return { type: String(tn).replace(/^Zod/, "").toLowerCase(), desc };
   }
 }
+function schemaToDescriptor(schema) {
+  if (!schema) return null;
+  const { schema: base, nullable } = unwrapSchema(schema);
+  const def = base?._def ?? base?.def;
+  const typeName = def?.typeName || def?.type;
+  const description = def?.description || base?.description;
+  let descriptor = {};
+  switch (typeName) {
+    case "ZodString":
+    case "string":
+      descriptor.type = "string";
+      break;
+    case "ZodNumber":
+    case "number":
+      descriptor.type = "number";
+      break;
+    case "ZodBoolean":
+    case "boolean":
+      descriptor.type = "boolean";
+      break;
+    case "ZodArray":
+    case "array": {
+      const inner = def?.element ?? def?.type;
+      descriptor.type = "array";
+      descriptor.items = schemaToDescriptor(inner);
+      break;
+    }
+    case "ZodObject":
+    case "object": {
+      const shapeSource = def?.shape || def?.shape_;
+      const shape = shapeSource && typeof shapeSource === "function" ? shapeSource.call(def) : shapeSource;
+      const properties = {};
+      const required = [];
+      if (shape && typeof shape === "object") {
+        for (const [key, value] of Object.entries(shape)) {
+          const { schema: fieldSchema, optional, nullable: fieldNullable } = unwrapSchema(value);
+          const fieldDescriptor = schemaToDescriptor(fieldSchema) ?? {};
+          if (fieldNullable) {
+            fieldDescriptor.nullable = true;
+          }
+          properties[key] = fieldDescriptor;
+          if (!optional) {
+            required.push(key);
+          }
+        }
+      }
+      descriptor.type = "object";
+      descriptor.properties = properties;
+      descriptor.required = required.length ? required : void 0;
+      break;
+    }
+    case "ZodUnion":
+    case "union": {
+      const options = def?.options ?? [];
+      descriptor.anyOf = options.map((option) => schemaToDescriptor(option)).filter(Boolean);
+      break;
+    }
+    case "ZodLiteral":
+    case "literal": {
+      const values3 = Array.isArray(def?.values) ? def.values : def?.value !== void 0 ? [def.value] : [];
+      const sample = values3.length ? values3[0] : void 0;
+      descriptor.type = sample === null ? "null" : typeof sample;
+      descriptor.enum = values3;
+      break;
+    }
+    case "ZodEnum":
+    case "enum":
+      const enumValues = Array.isArray(def?.values) ? def.values : Object.values(def?.entries ?? {});
+      descriptor.enum = enumValues;
+      if (enumValues.length) {
+        const hasNumber = enumValues.some((value) => typeof value === "number");
+        const hasString = enumValues.some((value) => typeof value === "string");
+        descriptor.type = hasNumber && !hasString ? "number" : "string";
+      } else {
+        descriptor.type = "string";
+      }
+      break;
+    case "ZodNativeEnum":
+    case "nativeenum": {
+      const values3 = Array.isArray(def?.values) ? def.values : Object.values(def?.entries ?? def?.values ?? {});
+      descriptor.type = values3.every((value) => typeof value === "number") ? "number" : "string";
+      descriptor.enum = values3;
+      break;
+    }
+    default:
+      descriptor.type = typeName ? String(typeName).replace(/^Zod/, "").toLowerCase() : "unknown";
+      break;
+  }
+  if (description) {
+    descriptor.description = description;
+  }
+  if (nullable) {
+    descriptor.nullable = true;
+  }
+  return descriptor;
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  let optional = false;
+  let nullable = false;
+  while (current) {
+    const def = current?._def ?? current?.def;
+    const typeName = def?.typeName || def?.type;
+    if (typeName === "ZodOptional" || typeName === "optional") {
+      optional = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodNullable" || typeName === "nullable") {
+      nullable = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodDefault" || typeName === "default") {
+      optional = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodEffects" || typeName === "effects") {
+      current = def?.schema;
+      continue;
+    }
+    if (typeName === "pipe") {
+      current = def?.in ?? def?.schema;
+      continue;
+    }
+    if (typeName === "transform") {
+      current = def?.schema ?? def?.in;
+      continue;
+    }
+    break;
+  }
+  return { schema: current, optional, nullable };
+}
 function formatSchemaLines(schema) {
   if (!schema) return ["none"];
   const def = schema._def ?? schema.def;
@@ -32012,7 +32152,7 @@ function formatSchemaLines(schema) {
       const tn = anyVal?._def?.typeName || anyVal?.def?.type;
       const typeString = summary2.type || (tn ? String(tn).replace(/^Zod/, "").toLowerCase() : void 0);
       const desc = summary2.desc;
-      const optional = tn === "ZodOptional" || tn === "ZodNullable";
+      const optional = ["ZodOptional", "optional", "ZodNullable", "nullable", "ZodDefault", "default"].includes(tn);
       const typePart = typeString ? `: ${typeString}` : "";
       const descPart = desc ? ` - ${desc}` : "";
       return `- ${key}${optional ? "?" : ""}${typePart}${descPart}`;