@svadmin/create 0.18.1 → 0.20.0

package/dist/index.js

@@ -5023,10 +5023,10 @@ var require_picocolors = __commonJS(function(exports, module) {
 });
 
 // src/index.ts
-var import_prompts = __toESM(require_prompts3(), 1);
-var import_picocolors = __toESM(require_picocolors(), 1);
-import fs from "node:fs";
-import path from "node:path";
+var import_prompts2 = __toESM(require_prompts3(), 1);
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
 import { spawnSync } from "node:child_process";
@@ -5127,6 +5127,1310 @@ function createProjectPackageJson(scaffold, options) {
   };
 }
 
+// src/infer-command.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var import_prompts = __toESM(require_prompts3(), 1);
+import fs from "node:fs";
+import path from "node:path";
+
+// ../core/src/inferencer-openapi.ts
+function isRef(obj) {
+  return obj !== null && typeof obj === "object" && "$ref" in obj && typeof obj.$ref === "string";
+}
+function resolveRef(ref, root) {
+  const parts = ref.replace("#/", "").split("/");
+  let current = root;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object")
+      return null;
+    current = current[part];
+    if (!current)
+      return null;
+  }
+  return current;
+}
+function resolveSchema(schemaOrRef, root) {
+  if (isRef(schemaOrRef)) {
+    return resolveRef(schemaOrRef.$ref, root);
+  }
+  return schemaOrRef;
+}
+function mapOpenAPITypeToFieldType(key, schema, root) {
+  const { type, format } = schema;
+  if (schema.enum && schema.enum.length > 0)
+    return "select";
+  if (type === "array") {
+    if (schema.items) {
+      const itemSchema = resolveSchema(schema.items, root);
+      if (itemSchema?.type === "string") {
+        const lk = key.toLowerCase();
+        if (lk.includes("image") || lk.includes("photo"))
+          return "images";
+        return "tags";
+      }
+    }
+    return "tags";
+  }
+  if (type === "object")
+    return "json";
+  if (type === "boolean")
+    return "boolean";
+  if (type === "number" || type === "integer")
+    return "number";
+  if (type === "string") {
+    if (format === "date" || format === "date-time")
+      return "date";
+    if (format === "email")
+      return "email";
+    if (format === "uri" || format === "url")
+      return "url";
+    if (format === "binary" || format === "byte")
+      return "image";
+    const lk = key.toLowerCase();
+    if (lk.includes("email"))
+      return "email";
+    if (lk.includes("phone") || lk.includes("tel"))
+      return "phone";
+    if (lk.includes("url") || lk.includes("link") || lk.includes("website"))
+      return "url";
+    if (lk.includes("avatar") || lk.includes("image") || lk.includes("photo") || lk.includes("logo"))
+      return "image";
+    if (lk.includes("color") || lk.includes("colour"))
+      return "color";
+    if (lk.includes("description") || lk.includes("content") || lk.includes("body") || lk.includes("bio"))
+      return "textarea";
+    if (lk === "created_at" || lk === "updated_at" || lk.endsWith("_at") || lk.endsWith("_date"))
+      return "date";
+    return "text";
+  }
+  return "text";
+}
+function inferFromOpenAPI(spec, options = {}) {
+  const { primaryKey = "id", include, exclude } = options;
+  const schemas = spec.components?.schemas ?? {};
+  const resources = [];
+  const resourcePaths = detectResourcePaths(spec);
+  for (const [schemaName, schemaObj] of Object.entries(schemas)) {
+    if (include && !include.includes(schemaName))
+      continue;
+    if (exclude && exclude.includes(schemaName))
+      continue;
+    const resolved = resolveSchema(schemaObj, spec);
+    if (!resolved || resolved.type !== "object" || !resolved.properties)
+      continue;
+    const fields = [];
+    const requiredFields = new Set(resolved.required ?? []);
+    for (const [propName, propSchemaOrRef] of Object.entries(resolved.properties)) {
+      const propSchema = resolveSchema(propSchemaOrRef, spec);
+      if (!propSchema)
+        continue;
+      const fieldType = mapOpenAPITypeToFieldType(propName, propSchema, spec);
+      let relatedResource = null;
+      if (isRef(propSchemaOrRef)) {
+        const refName = propSchemaOrRef.$ref.split("/").pop() ?? "";
+        relatedResource = refName.toLowerCase() + "s";
+      } else if (propName.endsWith("_id") || propName.endsWith("Id")) {
+        const base = propName.replace(/_id$|Id$/, "");
+        relatedResource = base.endsWith("s") ? base : base + "s";
+      }
+      const field = {
+        key: propName,
+        label: humanize(propName),
+        type: relatedResource ? "relation" : fieldType,
+        required: requiredFields.has(propName),
+        sortable: ["text", "number", "date"].includes(fieldType),
+        searchable: ["text", "email"].includes(fieldType),
+        showInList: propName !== primaryKey && fieldType !== "textarea" && fieldType !== "json",
+        showInForm: propName !== primaryKey
+      };
+      if (relatedResource) {
+        field.resource = relatedResource;
+        field.optionLabel = "name";
+        field.optionValue = "id";
+      }
+      if (propSchema.enum) {
+        field.options = propSchema.enum.map((v) => ({
+          label: String(v).charAt(0).toUpperCase() + String(v).slice(1),
+          value: v
+        }));
+      }
+      fields.push(field);
+    }
+    fields.sort((a, b) => {
+      if (a.key === primaryKey)
+        return -1;
+      if (b.key === primaryKey)
+        return 1;
+      return 0;
+    });
+    const baseName = schemaName.toLowerCase();
+    const resourceName = baseName.endsWith("s") ? baseName : baseName + "s";
+    const pathInfo = resourcePaths.get(baseName) ?? resourcePaths.get(resourceName);
+    resources.push({
+      name: resourceName,
+      label: schemaName,
+      primaryKey,
+      fields,
+      canCreate: pathInfo?.hasPost ?? true,
+      canEdit: pathInfo?.hasPut ?? true,
+      canDelete: pathInfo?.hasDelete ?? true,
+      canShow: pathInfo?.hasGet ?? true
+    });
+  }
+  return resources;
+}
+function detectResourcePaths(spec) {
+  const result = new Map;
+  if (!spec.paths)
+    return result;
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    const segments = path.split("/").filter(Boolean);
+    const resourceSegment = segments.find((s) => !s.startsWith("{") && s !== "api" && s !== "v1" && s !== "v2");
+    if (!resourceSegment)
+      continue;
+    const name = resourceSegment.toLowerCase();
+    const existing = result.get(name) ?? { hasGet: false, hasPost: false, hasPut: false, hasDelete: false };
+    if (methods.get)
+      existing.hasGet = true;
+    if (methods.post)
+      existing.hasPost = true;
+    if (methods.put || methods.patch)
+      existing.hasPut = true;
+    if (methods.delete)
+      existing.hasDelete = true;
+    result.set(name, existing);
+  }
+  return result;
+}
+function humanize(key) {
+  return key.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+// ../core/src/inferencer-graphql.ts
+var GRAPHQL_INTROSPECTION_QUERY = `query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      kind
+      name
+      description
+      fields(includeDeprecated: true) {
+        name
+        description
+        type {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+      enumValues(includeDeprecated: true) {
+        name
+        description
+      }
+    }
+  }
+}`;
+function unwrapType(typeRef) {
+  let current = typeRef;
+  let isRequired = false;
+  let isList = false;
+  if (current.kind === "NON_NULL") {
+    isRequired = true;
+    if (current.ofType)
+      current = current.ofType;
+  }
+  if (current.kind === "LIST") {
+    isList = true;
+    if (current.ofType) {
+      current = current.ofType;
+      if (current.kind === "NON_NULL") {
+        if (current.ofType)
+          current = current.ofType;
+      }
+    }
+  }
+  return {
+    baseName: current.name ?? "String",
+    kind: current.kind,
+    isList,
+    isRequired
+  };
+}
+function mapGraphQLTypeToFieldType(key, typeInfo, enumMap) {
+  const { baseName, isList } = typeInfo;
+  const lk = key.toLowerCase();
+  if (enumMap.has(baseName))
+    return "select";
+  if (isList) {
+    if (lk.includes("image") || lk.includes("photo") || lk.includes("avatar") || lk.includes("picture")) {
+      return "images";
+    }
+    return "tags";
+  }
+  switch (baseName) {
+    case "Int":
+    case "Float":
+    case "Decimal":
+    case "BigInt":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "Date":
+    case "DateTime":
+    case "Time":
+    case "Timestamp":
+      return "date";
+    case "JSON":
+    case "JsonObject":
+    case "JSONObject":
+    case "Json":
+      return "json";
+    case "ID":
+      return "text";
+    case "String":
+    default:
+      break;
+  }
+  if (lk.includes("email"))
+    return "email";
+  if (lk.includes("phone") || lk.includes("tel") || lk.includes("mobile"))
+    return "phone";
+  if (lk.includes("url") || lk.includes("link") || lk.includes("website"))
+    return "url";
+  if (lk.includes("avatar") || lk.includes("image") || lk.includes("photo") || lk.includes("thumbnail") || lk.includes("logo"))
+    return "image";
+  if (lk.includes("color") || lk.includes("colour"))
+    return "color";
+  if (lk.includes("description") || lk.includes("content") || lk.includes("body") || lk.includes("bio") || lk.includes("summary"))
+    return "textarea";
+  if (lk === "created_at" || lk === "updated_at" || lk.endsWith("_at") || lk.endsWith("_date") || /\bdate\b/.test(lk))
+    return "date";
+  return "text";
+}
+function parseGraphQLSDL(sdl) {
+  const types = [];
+  const queryType = { name: "Query" };
+  const mutationType = { name: "Mutation" };
+  const cleanSDL = sdl.replace(/#[^\n\r]*/g, "");
+  const enumRegex = /enum\s+([A-Za-z0-9_]+)\s*\{([^}]+)\}/g;
+  let match;
+  while ((match = enumRegex.exec(cleanSDL)) !== null) {
+    const enumName = match[1];
+    const rawValues = match[2].split(/\s+/).filter(Boolean);
+    types.push({
+      kind: "ENUM",
+      name: enumName,
+      enumValues: rawValues.map((v) => ({ name: v }))
+    });
+  }
+  const typeRegex = /type\s+([A-Za-z0-9_]+)\s*(?:implements\s+[A-Za-z0-9_&,\s]+)?\s*\{([^}]+)\}/g;
+  while ((match = typeRegex.exec(cleanSDL)) !== null) {
+    const typeName = match[1];
+    const fieldsBody = match[2];
+    const fieldLines = fieldsBody.split(`
+`).map((l) => l.trim()).filter(Boolean);
+    const fields = [];
+    for (const line of fieldLines) {
+      const fieldMatch = /^([A-Za-z0-9_]+)(?:\([^)]*\))?\s*:\s*([[\]A-Za-z0-9_!]+)/.exec(line);
+      if (!fieldMatch)
+        continue;
+      const fName = fieldMatch[1];
+      const rawType = fieldMatch[2];
+      const isNonNullable = rawType.endsWith("!");
+      const cleanType = isNonNullable ? rawType.slice(0, -1) : rawType;
+      const isList = cleanType.startsWith("[") && cleanType.endsWith("]");
+      const innerType = isList ? cleanType.slice(1, -1).replace(/!$/, "") : cleanType;
+      let typeRef = {
+        kind: "SCALAR",
+        name: innerType
+      };
+      if (isList) {
+        typeRef = {
+          kind: "LIST",
+          ofType: typeRef
+        };
+      }
+      if (isNonNullable) {
+        typeRef = {
+          kind: "NON_NULL",
+          ofType: typeRef
+        };
+      }
+      fields.push({
+        name: fName,
+        type: typeRef
+      });
+    }
+    types.push({
+      kind: "OBJECT",
+      name: typeName,
+      fields
+    });
+  }
+  return {
+    queryType,
+    mutationType,
+    types
+  };
+}
+function inferFromGraphQL(schemaOrIntrospection, options = {}) {
+  const { primaryKey = "id", include, exclude } = options;
+  let schemaBody;
+  if (typeof schemaOrIntrospection === "string") {
+    schemaBody = parseGraphQLSDL(schemaOrIntrospection);
+  } else if (schemaOrIntrospection && typeof schemaOrIntrospection === "object" && "data" in schemaOrIntrospection && schemaOrIntrospection.data?.__schema) {
+    schemaBody = schemaOrIntrospection.data.__schema;
+  } else if (schemaOrIntrospection && typeof schemaOrIntrospection === "object" && "__schema" in schemaOrIntrospection && schemaOrIntrospection.__schema) {
+    schemaBody = schemaOrIntrospection.__schema;
+  } else if (schemaOrIntrospection && typeof schemaOrIntrospection === "object" && "types" in schemaOrIntrospection && Array.isArray(schemaOrIntrospection.types)) {
+    schemaBody = schemaOrIntrospection;
+  } else {
+    return [];
+  }
+  const types = schemaBody.types ?? [];
+  const queryTypeName = schemaBody.queryType?.name ?? "Query";
+  const mutationTypeName = schemaBody.mutationType?.name ?? "Mutation";
+  const subscriptionTypeName = schemaBody.subscriptionType?.name ?? "Subscription";
+  const enumMap = new Map;
+  for (const t of types) {
+    if (t.kind === "ENUM" && t.name) {
+      const values = (t.enumValues ?? []).map((ev) => ev.name);
+      enumMap.set(t.name, values);
+    }
+  }
+  const objectTypeMap = new Map;
+  for (const t of types) {
+    if (t.kind === "OBJECT" && t.name) {
+      objectTypeMap.set(t.name, t);
+    }
+  }
+  const queryFields = new Set;
+  const queryType = objectTypeMap.get(queryTypeName);
+  if (queryType?.fields) {
+    for (const f of queryType.fields)
+      queryFields.add(f.name.toLowerCase());
+  }
+  const mutationFields = new Set;
+  const mutationType = objectTypeMap.get(mutationTypeName);
+  if (mutationType?.fields) {
+    for (const f of mutationType.fields)
+      mutationFields.add(f.name.toLowerCase());
+  }
+  const resources = [];
+  for (const typeObj of types) {
+    const typeName = typeObj.name;
+    if (!typeName)
+      continue;
+    if (typeName.startsWith("__") || typeName === queryTypeName || typeName === mutationTypeName || typeName === subscriptionTypeName || typeObj.kind !== "OBJECT" || !typeObj.fields || typeObj.fields.length === 0) {
+      continue;
+    }
+    if (include && !include.includes(typeName))
+      continue;
+    if (exclude && exclude.includes(typeName))
+      continue;
+    const baseName = typeName.toLowerCase();
+    const resourceName = baseName.endsWith("s") ? baseName : baseName + "s";
+    const fields = [];
+    for (const fieldDesc of typeObj.fields) {
+      const fieldName = fieldDesc.name;
+      const typeInfo = unwrapType(fieldDesc.type);
+      let fieldType = mapGraphQLTypeToFieldType(fieldName, typeInfo, enumMap);
+      let relatedResource = null;
+      if (objectTypeMap.has(typeInfo.baseName) && typeInfo.baseName !== typeName) {
+        const target = typeInfo.baseName.toLowerCase();
+        relatedResource = target.endsWith("s") ? target : target + "s";
+        fieldType = "relation";
+      } else if (fieldName.endsWith("_id") || fieldName.endsWith("Id")) {
+        const base = fieldName.replace(/_id$|Id$/, "");
+        relatedResource = base.endsWith("s") ? base : base + "s";
+        fieldType = "relation";
+      }
+      const field = {
+        key: fieldName,
+        label: humanize2(fieldName),
+        type: relatedResource ? "relation" : fieldType,
+        required: typeInfo.isRequired,
+        sortable: ["text", "number", "date"].includes(fieldType),
+        searchable: ["text", "email"].includes(fieldType),
+        showInList: fieldName !== primaryKey && fieldType !== "textarea" && fieldType !== "json",
+        showInForm: fieldName !== primaryKey
+      };
+      if (relatedResource) {
+        field.resource = relatedResource;
+        field.optionLabel = "name";
+        field.optionValue = "id";
+      }
+      if (enumMap.has(typeInfo.baseName)) {
+        const enumValues = enumMap.get(typeInfo.baseName) ?? [];
+        field.options = enumValues.map((val) => ({
+          label: humanize2(val),
+          value: val
+        }));
+      }
+      fields.push(field);
+    }
+    fields.sort((a, b) => {
+      if (a.key === primaryKey)
+        return -1;
+      if (b.key === primaryKey)
+        return 1;
+      return a.key.localeCompare(b.key);
+    });
+    const canShow = queryFields.size === 0 || queryFields.has(baseName) || queryFields.has(resourceName) || queryFields.has(`get${baseName}`) || queryFields.has(`${baseName}byid`) || queryFields.has(`find${baseName}`);
+    const canCreate = mutationFields.size === 0 || mutationFields.has(`create${baseName}`) || mutationFields.has(`insert${baseName}`) || mutationFields.has(`add${baseName}`) || mutationFields.has(`insert_${resourceName}`) || mutationFields.has(`create_${baseName}`);
+    const canEdit = mutationFields.size === 0 || mutationFields.has(`update${baseName}`) || mutationFields.has(`edit${baseName}`) || mutationFields.has(`update_${resourceName}`) || mutationFields.has(`update_${baseName}`) || mutationFields.has(`save${baseName}`);
+    const canDelete = mutationFields.size === 0 || mutationFields.has(`delete${baseName}`) || mutationFields.has(`remove${baseName}`) || mutationFields.has(`delete_${resourceName}`) || mutationFields.has(`delete_${baseName}`);
+    resources.push({
+      name: resourceName,
+      label: typeName,
+      primaryKey,
+      fields,
+      canCreate,
+      canEdit,
+      canDelete,
+      canShow
+    });
+  }
+  return resources;
+}
+function humanize2(key) {
+  return key.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+// ../core/src/inferencer.ts
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL_RE = /^https?:\/\//;
+var IMAGE_RE = /\.(png|jpe?g|gif|svg|webp|avif|ico)(\?.*)?$/i;
+var PHONE_RE = /^\+?[\d\s\-()]{7,}$/;
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?/;
+var COLOR_RE = /^#([0-9a-fA-F]{3,8})$/;
+function inferFieldType(key, value) {
+  if (value === null || value === undefined)
+    return "text";
+  if (typeof value === "boolean")
+    return "boolean";
+  if (typeof value === "number")
+    return "number";
+  if (Array.isArray(value)) {
+    if (value.length > 0 && typeof value[0] === "string") {
+      if (value.every((v) => typeof v === "string" && IMAGE_RE.test(v)))
+        return "images";
+      return "tags";
+    }
+    if (value.length > 0 && typeof value[0] === "number")
+      return "tags";
+    return "json";
+  }
+  if (typeof value === "object")
+    return "json";
+  if (typeof value === "string") {
+    if (COLOR_RE.test(value))
+      return "color";
+    if (EMAIL_RE.test(value))
+      return "email";
+    if (IMAGE_RE.test(value))
+      return "image";
+    if (URL_RE.test(value))
+      return "url";
+    if (PHONE_RE.test(value))
+      return "phone";
+    if (ISO_DATE_RE.test(value))
+      return "date";
+    if (value.length > 200)
+      return "textarea";
+    const lk = key.toLowerCase();
+    if (lk.includes("email"))
+      return "email";
+    if (lk.includes("phone") || lk.includes("tel") || lk.includes("mobile"))
+      return "phone";
+    if (lk.includes("url") || lk.includes("link") || lk.includes("website"))
+      return "url";
+    if (lk.includes("avatar") || lk.includes("image") || lk.includes("photo") || lk.includes("thumbnail") || lk.includes("logo"))
+      return "image";
+    if (lk.includes("color") || lk.includes("colour"))
+      return "color";
+    if (lk.includes("description") || lk.includes("content") || lk.includes("body") || lk.includes("bio") || lk.includes("summary"))
+      return "textarea";
+    if (lk === "created_at" || lk === "updated_at" || lk.endsWith("_at") || lk.endsWith("_date") || /\bdate\b/.test(lk))
+      return "date";
+    return "text";
+  }
+  return "text";
+}
+var RELATION_SUFFIXES = ["_id", "Id", "_ID"];
+function isLikelyRelation(key) {
+  for (const suffix of RELATION_SUFFIXES) {
+    if (key.endsWith(suffix)) {
+      const resource = key.slice(0, -suffix.length);
+      return resource.endsWith("s") ? resource : resource + "s";
+    }
+  }
+  return null;
+}
+function inferResource(resourceName, sampleData, options = {}) {
+  const primaryKey = options.primaryKey ?? "id";
+  const label = options.label ?? capitalize(resourceName);
+  if (!sampleData.length) {
+    const emptyResource = { name: resourceName, label, fields: [], primaryKey };
+    return {
+      fields: [],
+      resource: emptyResource,
+      code: `// No data available to infer fields for "${resourceName}".`,
+      typeboxCode: generateTypeBoxSchemaCode(emptyResource),
+      componentCode: {
+        list: generateListPageCode(emptyResource),
+        create: generateCreatePageCode(emptyResource),
+        edit: generateEditPageCode(emptyResource),
+        show: generateShowPageCode(emptyResource)
+      }
+    };
+  }
+  const keySet = new Set;
+  for (const row of sampleData) {
+    for (const k of Object.keys(row))
+      keySet.add(k);
+  }
+  const fields = [];
+  for (const key of keySet) {
+    const values = sampleData.map((r) => r[key]).filter((v) => v !== null && v !== undefined);
+    const sampleValue = values[0];
+    let inferredType = inferFieldType(key, sampleValue);
+    const typeCounts = new Map;
+    for (const v of values) {
+      const t = inferFieldType(key, v);
+      typeCounts.set(t, (typeCounts.get(t) ?? 0) + 1);
+    }
+    let maxCount = 0;
+    for (const [t, count] of typeCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        inferredType = t;
+      }
+    }
+    const relatedResource = isLikelyRelation(key);
+    const uniqueStrings = new Set(values.filter((v) => typeof v === "string"));
+    const isSelect = inferredType === "text" && uniqueStrings.size > 1 && uniqueStrings.size <= 10 && values.length >= 5;
+    const field = {
+      key,
+      label: humanize3(key),
+      type: relatedResource ? "relation" : isSelect ? "select" : inferredType,
+      sortable: inferredType === "text" || inferredType === "number" || inferredType === "date",
+      searchable: inferredType === "text" || inferredType === "email",
+      showInList: key !== primaryKey && inferredType !== "textarea" && inferredType !== "json" && inferredType !== "richtext",
+      showInForm: key !== primaryKey
+    };
+    if (relatedResource) {
+      field.resource = relatedResource;
+      field.optionLabel = "name";
+      field.optionValue = "id";
+    }
+    if (isSelect) {
+      field.options = [...uniqueStrings].map((v) => ({ label: capitalize(v), value: v }));
+    }
+    fields.push(field);
+  }
+  fields.sort((a, b) => {
+    if (a.key === primaryKey)
+      return -1;
+    if (b.key === primaryKey)
+      return 1;
+    return a.key.localeCompare(b.key);
+  });
+  const resource = {
+    name: resourceName,
+    label,
+    primaryKey,
+    fields,
+    canCreate: true,
+    canEdit: true,
+    canDelete: true,
+    canShow: true
+  };
+  const code = generateCode(resource);
+  const typeboxCode = generateTypeBoxSchemaCode(resource);
+  const componentCode = {
+    list: generateListPageCode(resource),
+    create: generateCreatePageCode(resource),
+    edit: generateEditPageCode(resource),
+    show: generateShowPageCode(resource)
+  };
+  return { fields, resource, code, typeboxCode, componentCode };
+}
+function generateCode(resource) {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const fieldsCode = resource.fields.map((f) => {
+    const lines = [
+      `    { key: '${esc(f.key)}', label: '${esc(f.label)}', type: '${f.type}'`
+    ];
+    if (f.sortable)
+      lines.push(`      sortable: true`);
+    if (f.searchable)
+      lines.push(`      searchable: true`);
+    if (f.showInList === false)
+      lines.push(`      showInList: false`);
+    if (f.showInForm === false)
+      lines.push(`      showInForm: false`);
+    if (f.resource) {
+      lines.push(`      resource: '${f.resource}'`);
+      lines.push(`      optionLabel: '${f.optionLabel}'`);
+      lines.push(`      optionValue: '${f.optionValue}'`);
+    }
+    if (f.options) {
+      lines.push(`      options: ${JSON.stringify(f.options)}`);
+    }
+    return lines.join(`,
+`) + " }";
+  }).join(`,
+`);
+  return `import type { ResourceDefinition } from '@svadmin/core';
+
+export const ${resource.name}Resource: ResourceDefinition = {
+  name: '${resource.name}',
+  label: '${resource.label}',
+  primaryKey: '${resource.primaryKey ?? "id"}',
+  canCreate: true,
+  canEdit: true,
+  canDelete: true,
+  canShow: true,
+  fields: [
+${fieldsCode}
+  ],
+};
+`;
+}
+function generateListPageCode(resource) {
+  return `<script lang="ts">
+  import { ListPage, AutoTable } from '@svadmin/ui';
+</script>
+
+<ListPage resourceName="${resource.name}">
+  <AutoTable resourceName="${resource.name}" />
+</ListPage>
+`;
+}
+function generateCreatePageCode(resource) {
+  return `<script lang="ts">
+  import { CreatePage, AutoForm } from '@svadmin/ui';
+</script>
+
+<CreatePage resourceName="${resource.name}">
+  <AutoForm resourceName="${resource.name}" mode="create" />
+</CreatePage>
+`;
+}
+function generateEditPageCode(resource) {
+  return `<script lang="ts">
+  import { EditPage, AutoForm } from '@svadmin/ui';
+
+  interface Props {
+    id?: string | number;
+  }
+
+  let { id }: Props = $props();
+</script>
+
+<EditPage resourceName="${resource.name}" {id}>
+  <AutoForm resourceName="${resource.name}" {id} mode="edit" />
+</EditPage>
+`;
+}
+function generateShowPageCode(resource) {
+  return `<script lang="ts">
+  import { ShowPage, AutoForm } from '@svadmin/ui';
+
+  interface Props {
+    id?: string | number;
+  }
+
+  let { id }: Props = $props();
+</script>
+
+<ShowPage resourceName="${resource.name}" {id}>
+  <AutoForm resourceName="${resource.name}" {id} mode="show" />
+</ShowPage>
+`;
+}
+function generateResourceCode(resource) {
+  return generateCode(resource);
+}
+function generateTypeBoxSchemaCode(resource) {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const schemaProps = resource.fields.map((f) => {
+    let typeDef;
+    const isRequired = f.required === true;
+    switch (f.type) {
+      case "number":
+        typeDef = "Type.Number()";
+        break;
+      case "boolean":
+        typeDef = "Type.Boolean()";
+        break;
+      case "date":
+        typeDef = "Type.String({ format: 'date-time' })";
+        break;
+      case "email":
+        typeDef = "Type.String({ format: 'email' })";
+        break;
+      case "url":
+        typeDef = "Type.String({ format: 'uri' })";
+        break;
+      case "phone":
+        typeDef = "Type.String({ pattern: '^\\\\+?[\\\\d\\\\s\\\\-()]{7,}$' })";
+        break;
+      case "tags":
+        typeDef = "Type.Array(Type.String())";
+        break;
+      case "images":
+        typeDef = "Type.Array(Type.String({ format: 'uri' }))";
+        break;
+      case "json":
+        typeDef = "Type.Record(Type.String(), Type.Unknown())";
+        break;
+      case "select":
+        if (f.options && f.options.length > 0) {
+          const literals = f.options.map((o) => `Type.Literal('${esc(String(o.value))}')`).join(", ");
+          typeDef = `Type.Union([${literals}])`;
+        } else {
+          typeDef = "Type.String()";
+        }
+        break;
+      case "relation":
+        typeDef = "Type.Union([Type.String(), Type.Number()])";
+        break;
+      case "textarea":
+      case "richtext":
+      case "text":
+      default:
+        typeDef = "Type.String()";
+        break;
+    }
+    if (!isRequired && f.key !== (resource.primaryKey ?? "id")) {
+      typeDef = `Type.Optional(${typeDef})`;
+    }
+    return `  ${f.key}: ${typeDef},`;
+  }).join(`
+`);
+  const baseName = resource.name.endsWith("s") ? resource.name.slice(0, -1) : resource.name;
+  const typeName = capitalize(baseName);
+  return `import { Type, type Static } from '@sinclair/typebox';
+
+export const ${typeName}Schema = Type.Object({
+${schemaProps}
+});
+
+export type ${typeName} = Static<typeof ${typeName}Schema>;
+`;
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function humanize3(key) {
+  return key.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function generateResourceBundle(resource) {
+  return {
+    fields: resource.fields,
+    resource,
+    code: generateResourceCode(resource),
+    typeboxCode: generateTypeBoxSchemaCode(resource),
+    componentCode: {
+      list: generateListPageCode(resource),
+      create: generateCreatePageCode(resource),
+      edit: generateEditPageCode(resource),
+      show: generateShowPageCode(resource)
+    }
+  };
+}
+
+// src/infer-command.ts
+function parseInferArguments(args) {
+  const options = {
+    headers: {},
+    primaryKey: "id",
+    method: "GET",
+    format: "all"
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--write" || arg === "-w") {
+      options.write = true;
+    } else if (arg === "--dry-run") {
+      options.write = false;
+    } else if (arg === "--url" || arg === "-u") {
+      options.url = args[++i];
+    } else if (arg.startsWith("--url=")) {
+      options.url = arg.slice(6);
+    } else if (arg === "--file" || arg === "-f") {
+      options.file = args[++i];
+    } else if (arg.startsWith("--file=")) {
+      options.file = arg.slice(7);
+    } else if (arg === "--type" || arg === "-t") {
+      options.type = args[++i];
+    } else if (arg.startsWith("--type=")) {
+      options.type = arg.slice(7);
+    } else if (arg === "--resource" || arg === "-r") {
+      options.resource = args[++i];
+    } else if (arg.startsWith("--resource=")) {
+      options.resource = arg.slice(11);
+    } else if (arg === "--out-dir" || arg === "-o" || arg === "--output") {
+      options.outDir = args[++i];
+    } else if (arg.startsWith("--out-dir=")) {
+      options.outDir = arg.slice(10);
+    } else if (arg.startsWith("--output=")) {
+      options.outDir = arg.slice(9);
+    } else if (arg === "--primary-key" || arg === "-k") {
+      options.primaryKey = args[++i];
+    } else if (arg.startsWith("--primary-key=")) {
+      options.primaryKey = arg.slice(14);
+    } else if (arg === "--header" || arg === "-H") {
+      const headerLine = args[++i] ?? "";
+      const colonIndex = headerLine.indexOf(":");
+      if (colonIndex > 0) {
+        const key = headerLine.slice(0, colonIndex).trim();
+        const value = headerLine.slice(colonIndex + 1).trim();
+        if (!options.headers)
+          options.headers = {};
+        options.headers[key] = value;
+      }
+    } else if (arg.startsWith("--header=")) {
+      const headerLine = arg.slice(9);
+      const colonIndex = headerLine.indexOf(":");
+      if (colonIndex > 0) {
+        const key = headerLine.slice(0, colonIndex).trim();
+        const value = headerLine.slice(colonIndex + 1).trim();
+        if (!options.headers)
+          options.headers = {};
+        options.headers[key] = value;
+      }
+    } else if (arg === "--method" || arg === "-m") {
+      options.method = (args[++i] ?? "GET").toUpperCase();
+    } else if (arg.startsWith("--method=")) {
+      options.method = arg.slice(9).toUpperCase();
+    } else if (arg === "--body" || arg === "-b") {
+      options.body = args[++i];
+    } else if (arg.startsWith("--body=")) {
+      options.body = arg.slice(7);
+    } else if (arg === "--format") {
+      options.format = args[++i];
+    } else if (arg.startsWith("--format=")) {
+      options.format = arg.slice(9);
+    } else if (arg === "--help" || arg === "-h") {
+      printInferHelp();
+      process.exit(0);
+    } else if (!arg.startsWith("-") && !options.url && !options.file) {
+      if (arg.startsWith("http://") || arg.startsWith("https://")) {
+        options.url = arg;
+      } else if (fs.existsSync(arg)) {
+        options.file = arg;
+      } else {
+        options.resource = arg;
+      }
+    }
+  }
+  return options;
+}
+function printInferHelp() {
+  console.log(`
+${import_picocolors.default.bold("svadmin infer")} — Automatically infer ResourceDefinitions, TypeBox Schemas, and Svelte 5 CRUD components from REST/GraphQL APIs or OpenAPI specs.
+
+${import_picocolors.default.bold("USAGE:")}
+  svadmin infer [OPTIONS]
+  svadmin infer <url|file> [OPTIONS]
+
+${import_picocolors.default.bold("OPTIONS:")}
+  -u, --url <url>              REST API endpoint, OpenAPI schema URL, or GraphQL endpoint
+  -f, --file <path>            Local OpenAPI JSON/YAML, GraphQL schema (.graphql/JSON), or sample JSON data file
+  -t, --type <type>            Explicit source type: rest | openapi | graphql | auto (default: auto)
+  -r, --resource <name>        Target resource name filter or explicit resource name for sample data
+  -o, --out-dir <dir>          Target directory for generated code (e.g. src/resources)
+  -k, --primary-key <key>      Primary key field name (default: id)
+  -H, --header <key:value>     Custom HTTP header for fetch requests (can be specified multiple times)
+  -m, --method <GET|POST>      HTTP method for REST fetch (default: GET)
+  -b, --body <json>            HTTP request body for POST requests
+  -w, --write                  Write generated files to target directory (default is dry-run when --out-dir is set)
+      --format <all|resource|typebox|components>
+                               Output format (default: all)
+  -h, --help                   Show this help message
+
+${import_picocolors.default.bold("EXAMPLES:")}
+  svadmin infer --url https://api.example.com/openapi.json --out-dir src/resources --write
+  svadmin infer --url https://api.example.com/graphql --out-dir src/resources --write
+  svadmin infer --url https://api.example.com/api/v1/posts --resource posts
+  svadmin infer --file schema.graphql --out-dir src/resources --write
+  svadmin infer --file sample-posts.json --resource posts --out-dir src/resources --write
+`);
+}
+async function loadSourceData(options, customFetch = fetch) {
+  if (options.file) {
+    const filePath = path.resolve(process.cwd(), options.file);
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const ext = path.extname(filePath).toLowerCase();
+    const baseName = path.basename(filePath, ext);
+    if (ext === ".graphql" || ext === ".gql") {
+      return {
+        sourceType: "graphql",
+        data: content,
+        derivedResourceName: options.resource || baseName,
+        sourceDescription: options.file
+      };
+    }
+    try {
+      const json = JSON.parse(content);
+      if (typeof json === "object" && json !== null && (("openapi" in json) || ("swagger" in json) || ("paths" in json) && ("components" in json))) {
+        return {
+          sourceType: "openapi",
+          data: json,
+          derivedResourceName: options.resource,
+          sourceDescription: options.file
+        };
+      }
+      if (typeof json === "object" && json !== null && (("__schema" in json) || ("data" in json) && json.data && ("__schema" in json.data) || ("types" in json) && Array.isArray(json.types))) {
+        return {
+          sourceType: "graphql",
+          data: json,
+          derivedResourceName: options.resource,
+          sourceDescription: options.file
+        };
+      }
+      const records = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : Array.isArray(json.items) ? json.items : [json];
+      return {
+        sourceType: "rest",
+        data: records,
+        derivedResourceName: options.resource || baseName,
+        sourceDescription: options.file
+      };
+    } catch {
+      if (content.includes("type ") || content.includes("enum ") || content.includes("schema ")) {
+        return {
+          sourceType: "graphql",
+          data: content,
+          derivedResourceName: options.resource || baseName,
+          sourceDescription: options.file
+        };
+      }
+      throw new Error(`Unable to parse file ${filePath}. Expected valid JSON or GraphQL SDL schema.`);
+    }
+  }
+  if (options.url) {
+    const url = options.url;
+    const isGraphQL = options.type === "graphql" || url.endsWith("/graphql") || url.includes("/graphql?");
+    if (isGraphQL) {
+      const response2 = await customFetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...options.headers ?? {}
+        },
+        body: JSON.stringify({ query: GRAPHQL_INTROSPECTION_QUERY })
+      });
+      if (!response2.ok) {
+        throw new Error(`GraphQL introspection request failed: HTTP ${response2.status} ${response2.statusText}`);
+      }
+      const json2 = await response2.json();
+      return {
+        sourceType: "graphql",
+        data: json2,
+        derivedResourceName: options.resource,
+        sourceDescription: url
+      };
+    }
+    const response = await customFetch(url, {
+      method: options.method ?? "GET",
+      headers: {
+        Accept: "application/json",
+        ...options.headers ?? {}
+      },
+      body: options.body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP request failed: HTTP ${response.status} ${response.statusText}`);
+    }
+    const json = await response.json();
+    if (typeof json === "object" && json !== null && (("openapi" in json) || ("swagger" in json) || ("paths" in json) && ("components" in json))) {
+      return {
+        sourceType: "openapi",
+        data: json,
+        derivedResourceName: options.resource,
+        sourceDescription: url
+      };
+    }
+    if (typeof json === "object" && json !== null && (("__schema" in json) || ("data" in json) && json.data?.__schema)) {
+      return {
+        sourceType: "graphql",
+        data: json,
+        derivedResourceName: options.resource,
+        sourceDescription: url
+      };
+    }
+    let derivedName = options.resource;
+    if (!derivedName) {
+      try {
+        const parsedUrl = new URL(url);
+        const segments = parsedUrl.pathname.split("/").filter(Boolean);
+        derivedName = segments.pop() || "items";
+      } catch {
+        derivedName = "items";
+      }
+    }
+    const records = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : Array.isArray(json.items) ? json.items : [json];
+    return {
+      sourceType: "rest",
+      data: records,
+      derivedResourceName: derivedName,
+      sourceDescription: url
+    };
+  }
+  throw new Error("Must provide either --url <url> or --file <path>");
+}
+function planGeneratedFiles(resources, bundles, format = "all") {
+  const files = [];
+  const exportLines = [];
+  for (const resource of resources) {
+    const bundle = bundles.get(resource.name);
+    if (!bundle)
+      continue;
+    const baseName = resource.name;
+    const pascalName = capitalize2(resource.name.endsWith("s") ? resource.name.slice(0, -1) : resource.name);
+    if (format === "all" || format === "resource") {
+      files.push({
+        relativePath: `${baseName}.resource.ts`,
+        content: bundle.code
+      });
+      exportLines.push(`export * from './${baseName}.resource.js';`);
+    }
+    if (format === "all" || format === "typebox") {
+      files.push({
+        relativePath: `${baseName}.schema.ts`,
+        content: bundle.typeboxCode
+      });
+      exportLines.push(`export * from './${baseName}.schema.js';`);
+    }
+    if (format === "all" || format === "components") {
+      files.push({
+        relativePath: `${baseName}/ListPage.svelte`,
+        content: bundle.componentCode.list
+      });
+      files.push({
+        relativePath: `${baseName}/CreatePage.svelte`,
+        content: bundle.componentCode.create
+      });
+      files.push({
+        relativePath: `${baseName}/EditPage.svelte`,
+        content: bundle.componentCode.edit
+      });
+      files.push({
+        relativePath: `${baseName}/ShowPage.svelte`,
+        content: bundle.componentCode.show
+      });
+      exportLines.push(`export { default as ${pascalName}ListPage } from './${baseName}/ListPage.svelte';`);
+      exportLines.push(`export { default as ${pascalName}CreatePage } from './${baseName}/CreatePage.svelte';`);
+      exportLines.push(`export { default as ${pascalName}EditPage } from './${baseName}/EditPage.svelte';`);
+      exportLines.push(`export { default as ${pascalName}ShowPage } from './${baseName}/ShowPage.svelte';`);
+    }
+  }
+  if (files.length > 0) {
+    files.push({
+      relativePath: "index.ts",
+      content: `// Auto-generated by @svadmin/create infer
+
+${exportLines.join(`
+`)}
+`
+    });
+  }
+  return files;
+}
+async function executeInfer(options, customFetch = fetch) {
+  const loaded = await loadSourceData(options, customFetch);
+  const primaryKey = options.primaryKey ?? "id";
+  let resources;
+  const bundles = new Map;
+  if (loaded.sourceType === "openapi") {
+    resources = inferFromOpenAPI(loaded.data, {
+      primaryKey,
+      include: options.resource ? [options.resource] : undefined
+    });
+    for (const res of resources) {
+      bundles.set(res.name, generateResourceBundle(res));
+    }
+  } else if (loaded.sourceType === "graphql") {
+    resources = inferFromGraphQL(loaded.data, {
+      primaryKey,
+      include: options.resource ? [options.resource] : undefined
+    });
+    for (const res of resources) {
+      bundles.set(res.name, generateResourceBundle(res));
+    }
+  } else {
+    const resName = options.resource || loaded.derivedResourceName || "items";
+    const sampleArray = Array.isArray(loaded.data) ? loaded.data : [loaded.data];
+    const inferRes = inferResource(resName, sampleArray, { primaryKey });
+    resources = [inferRes.resource];
+    bundles.set(resName, inferRes);
+  }
+  if (resources.length === 0) {
+    throw new Error(`No resources could be inferred from ${loaded.sourceDescription}`);
+  }
+  const files = planGeneratedFiles(resources, bundles, options.format);
+  let wrote = false;
+  if (options.outDir && options.write) {
+    const targetDir = path.resolve(process.cwd(), options.outDir);
+    for (const file of files) {
+      const fullPath = path.join(targetDir, file.relativePath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, file.content, "utf-8");
+    }
+    wrote = true;
+  }
+  return {
+    resources,
+    bundles,
+    files,
+    sourceDescription: loaded.sourceDescription,
+    wrote,
+    outDir: options.outDir
+  };
+}
+function printInferResult(result) {
+  console.log();
+  console.log(import_picocolors.default.cyan("  ╔═══════════════════════════════════╗"));
+  console.log(import_picocolors.default.cyan("  ║  ") + import_picocolors.default.bold("svadmin infer") + import_picocolors.default.cyan("                    ║"));
+  console.log(import_picocolors.default.cyan("  ║  ") + import_picocolors.default.dim("Automated Code & UI Inferencer") + import_picocolors.default.cyan(" ║"));
+  console.log(import_picocolors.default.cyan("  ╚═══════════════════════════════════╝"));
+  console.log();
+  console.log(import_picocolors.default.bold(`  Source: ${import_picocolors.default.cyan(result.sourceDescription)}`));
+  console.log(import_picocolors.default.bold(`  Inferred: ${import_picocolors.default.green(result.resources.length.toString())} resource(s): ${result.resources.map((r) => r.name).join(", ")}`));
+  console.log();
+  if (result.outDir) {
+    if (result.wrote) {
+      console.log(import_picocolors.default.green(`  ✔ Written ${result.files.length} file(s) to ${import_picocolors.default.cyan(result.outDir)}:`));
+      for (const file of result.files) {
+        console.log(`    ${import_picocolors.default.green("•")} ${path.join(result.outDir, file.relativePath)}`);
+      }
+      console.log();
+      console.log(import_picocolors.default.dim("  Next step: import and register your generated resources in src/resources.ts"));
+    } else {
+      console.log(import_picocolors.default.yellow(`  Dry run plan — ${result.files.length} file(s) planned for ${import_picocolors.default.cyan(result.outDir)}:`));
+      for (const file of result.files) {
+        console.log(`    ${import_picocolors.default.cyan("•")} ${path.join(result.outDir, file.relativePath)}`);
+      }
+      console.log();
+      console.log(import_picocolors.default.yellow("  Dry run only; re-run with --write to generate files to disk."));
+    }
+  } else {
+    for (const res of result.resources) {
+      const bundle = result.bundles.get(res.name);
+      console.log(import_picocolors.default.bold(`  Resource: ${import_picocolors.default.green(res.name)} (${res.label})`));
+      console.log(`  Primary Key: ${import_picocolors.default.cyan(res.primaryKey ?? "id")} | Fields: ${res.fields.length}`);
+      console.log(import_picocolors.default.dim("  Fields:"));
+      for (const f of res.fields) {
+        const badges = [
+          f.type,
+          f.required ? "required" : null,
+          f.resource ? `-> ${f.resource}` : null,
+          f.showInList ? "list" : null,
+          f.showInForm ? "form" : null
+        ].filter(Boolean).join(", ");
+        console.log(`    ${import_picocolors.default.cyan(f.key)}: ${import_picocolors.default.dim(`(${badges})`)}`);
+      }
+      console.log();
+      if (bundle) {
+        console.log(import_picocolors.default.bold("  TypeBox Schema:"));
+        console.log(import_picocolors.default.dim("  ───────────────────────────────────"));
+        console.log(bundle.typeboxCode.trim());
+        console.log(import_picocolors.default.dim("  ───────────────────────────────────"));
+        console.log();
+      }
+    }
+    console.log(import_picocolors.default.dim("  Tip: Pass --out-dir src/resources --write to save generated files directly."));
+  }
+  console.log();
+}
+async function promptInferWizard() {
+  const answers = await import_prompts.default([
+    {
+      type: "select",
+      name: "sourceType",
+      message: "Select API source type:",
+      choices: [
+        { title: "REST API Endpoint (URL)", value: "rest-url", description: "Fetch sample JSON data from REST endpoint" },
+        { title: "OpenAPI / Swagger Spec (URL or File)", value: "openapi", description: "OpenAPI 3.x / Swagger schema definition" },
+        { title: "GraphQL Endpoint (URL or Schema File)", value: "graphql", description: "GraphQL introspection or SDL schema" },
+        { title: "Local Sample JSON File", value: "rest-file", description: "JSON file with sample data records" }
+      ],
+      initial: 0
+    },
+    {
+      type: (prev) => prev === "rest-file" || prev === "openapi" ? "text" : null,
+      name: "pathOrUrl",
+      message: "Enter URL or File path:",
+      validate: (v) => v.trim() ? true : "URL or file path is required"
+    },
+    {
+      type: (prev, values) => values.sourceType === "rest-url" || values.sourceType === "graphql" ? "text" : null,
+      name: "endpointUrl",
+      message: "Enter Endpoint URL:",
+      validate: (v) => v.trim().startsWith("http") ? true : "Must be a valid HTTP(S) URL"
+    },
+    {
+      type: "text",
+      name: "outDir",
+      message: "Target output directory:",
+      initial: "src/resources"
+    },
+    {
+      type: "confirm",
+      name: "write",
+      message: "Write generated files to disk now?",
+      initial: true
+    }
+  ]);
+  const targetPath = answers.pathOrUrl || answers.endpointUrl;
+  const isUrl = targetPath?.startsWith("http://") || targetPath?.startsWith("https://");
+  return {
+    url: isUrl ? targetPath : undefined,
+    file: !isUrl ? targetPath : undefined,
+    type: answers.sourceType.startsWith("graphql") ? "graphql" : answers.sourceType.startsWith("openapi") ? "openapi" : "rest",
+    outDir: answers.outDir,
+    write: answers.write
+  };
+}
+async function inferCommand(args) {
+  let options = parseInferArguments(args);
+  if (!options.url && !options.file && process.stdin.isTTY) {
+    options = await promptInferWizard();
+  }
+  if (!options.url && !options.file) {
+    printInferHelp();
+    return;
+  }
+  const result = await executeInfer(options);
+  printInferResult(result);
+}
+function capitalize2(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
 // src/project-maintenance.ts
 import {
   constants,
@@ -5136,10 +6440,10 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-function parseDependencyMap(candidate, path) {
+function parseDependencyMap(candidate, path2) {
   if (candidate === undefined)
     return;
-  assertStringRecord(candidate, path);
+  assertStringRecord(candidate, path2);
   return { ...candidate };
 }
 function parseMaintainedPackageJson(packageJsonCandidate) {
@@ -5415,15 +6719,15 @@ function writeProjectPackageJsonUpgrade(packagePath, scaffold, backupDate) {
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
+var __dirname2 = path2.dirname(__filename2);
 function loadShippedScaffoldManifest() {
-  return loadScaffoldManifest(path.join(__dirname2, "..", "scaffold-manifest.json"));
+  return loadScaffoldManifest(path2.join(__dirname2, "..", "scaffold-manifest.json"));
 }
 function projectDirectoryFromArguments(positional) {
   if (positional.length > 1) {
     throw new Error(`Expected at most one project directory, received: ${positional.join(", ")}`);
   }
-  return path.resolve(process.cwd(), positional[0] ?? ".");
+  return path2.resolve(process.cwd(), positional[0] ?? ".");
 }
 function doctorProjectDirectory(args) {
   const unknownOption = args.find((argument) => argument.startsWith("-"));
@@ -5459,52 +6763,52 @@ function upgradeChangeMessage(change) {
   return `update ${change.packageName} from ${change.from ?? "missing"} to ${change.to}`;
 }
 function printDoctorIssue(issue) {
-  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors.default.yellow("  ⚠") : import_picocolors.default.red("  ✗");
+  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors2.default.yellow("  ⚠") : import_picocolors2.default.red("  ✗");
   console.log(`${marker} ${doctorIssueMessage(issue)}`);
-  console.log(import_picocolors.default.dim(`    → ${issue.action}`));
+  console.log(import_picocolors2.default.dim(`    → ${issue.action}`));
 }
 function printDoctorReport(report, projectDirectory) {
   console.log();
-  console.log(import_picocolors.default.bold(`svadmin doctor — ${projectDirectory}`));
+  console.log(import_picocolors2.default.bold(`svadmin doctor — ${projectDirectory}`));
   if (report.status === "clean") {
-    console.log(import_picocolors.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
+    console.log(import_picocolors2.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
   } else {
     for (const issue of report.issues)
       printDoctorIssue(issue);
     console.log();
-    console.log(import_picocolors.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
+    console.log(import_picocolors2.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
   }
   console.log();
 }
 function doctor(args) {
   const projectDirectory = doctorProjectDirectory(args);
-  const project = readMaintainedPackageJson(path.join(projectDirectory, "package.json"));
+  const project = readMaintainedPackageJson(path2.join(projectDirectory, "package.json"));
   const report = doctorProjectPackageJson(project, loadShippedScaffoldManifest());
   printDoctorReport(report, projectDirectory);
   process.exitCode = report.exitCode;
 }
 function printUpgradeChanges(upgradeExecution) {
   for (const change of upgradeExecution.plan.changes) {
-    console.log(`  ${import_picocolors.default.cyan("•")} ${upgradeChangeMessage(change)}`);
+    console.log(`  ${import_picocolors2.default.cyan("•")} ${upgradeChangeMessage(change)}`);
   }
   console.log();
 }
 function printUpgradeOutcome(upgradeExecution, packagePath) {
   if (upgradeExecution.wrote) {
-    console.log(import_picocolors.default.green("  ✔ package.json updated."));
-    console.log(`  Backup: ${import_picocolors.default.cyan(upgradeExecution.backupPath)}`);
-    console.log(`  Restore by copying the backup over: ${import_picocolors.default.cyan(packagePath)}`);
+    console.log(import_picocolors2.default.green("  ✔ package.json updated."));
+    console.log(`  Backup: ${import_picocolors2.default.cyan(upgradeExecution.backupPath)}`);
+    console.log(`  Restore by copying the backup over: ${import_picocolors2.default.cyan(packagePath)}`);
   } else {
-    console.log(import_picocolors.default.yellow("  Dry run only; package.json was not changed."));
+    console.log(import_picocolors2.default.yellow("  Dry run only; package.json was not changed."));
     console.log("  Re-run this command with --write to apply the plan.");
   }
   console.log();
 }
 function printUpgradeExecution(upgradeExecution, projectDirectory, packagePath) {
   console.log();
-  console.log(import_picocolors.default.bold(`svadmin upgrade — ${projectDirectory}`));
+  console.log(import_picocolors2.default.bold(`svadmin upgrade — ${projectDirectory}`));
   if (upgradeExecution.plan.changes.length === 0) {
-    console.log(import_picocolors.default.green("  ✔ package.json already matches the shipped scaffold."));
+    console.log(import_picocolors2.default.green("  ✔ package.json already matches the shipped scaffold."));
     console.log();
     return;
   }
@@ -5513,60 +6817,60 @@ function printUpgradeExecution(upgradeExecution, projectDirectory, packagePath)
 }
 function upgrade(args) {
   const commandArguments = parseUpgradeArguments(args);
-  const packagePath = path.join(commandArguments.projectDirectory, "package.json");
+  const packagePath = path2.join(commandArguments.projectDirectory, "package.json");
   const scaffoldManifest = loadShippedScaffoldManifest();
   const upgradeExecution = commandArguments.write ? writeProjectPackageJsonUpgrade(packagePath, scaffoldManifest, new Date) : planProjectPackageFileUpgrade(packagePath, scaffoldManifest);
   printUpgradeExecution(upgradeExecution, commandArguments.projectDirectory, packagePath);
 }
 var GUIDANCE_FILES = ["DESIGN.md", "AGENTS.md"];
 function missingGuidanceFiles(projectDirectory) {
-  return GUIDANCE_FILES.filter((fileName) => !fs.existsSync(path.join(projectDirectory, fileName)));
+  return GUIDANCE_FILES.filter((fileName) => !fs2.existsSync(path2.join(projectDirectory, fileName)));
 }
 function printGuidancePlan(projectDirectory, missingFiles) {
   console.log();
-  console.log(import_picocolors.default.bold(`svadmin guidance — ${projectDirectory}`));
+  console.log(import_picocolors2.default.bold(`svadmin guidance — ${projectDirectory}`));
   for (const fileName of missingFiles) {
-    console.log(`  ${import_picocolors.default.cyan("•")} add ${fileName}`);
+    console.log(`  ${import_picocolors2.default.cyan("•")} add ${fileName}`);
   }
   console.log();
 }
 function installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles) {
   for (const fileName of missingFiles) {
-    fs.copyFileSync(path.join(guidanceDirectory, fileName), path.join(projectDirectory, fileName));
+    fs2.copyFileSync(path2.join(guidanceDirectory, fileName), path2.join(projectDirectory, fileName));
   }
 }
 function guidance(args) {
   const { projectDirectory, write } = parseUpgradeArguments(args);
-  const guidanceDirectory = path.join(__dirname2, "..", "guidance");
-  if (!fs.existsSync(projectDirectory))
+  const guidanceDirectory = path2.join(__dirname2, "..", "guidance");
+  if (!fs2.existsSync(projectDirectory))
     throw new Error(`Project directory does not exist: ${projectDirectory}`);
-  if (!fs.existsSync(guidanceDirectory))
+  if (!fs2.existsSync(guidanceDirectory))
     throw new Error("Shipped svadmin guidance files are missing");
   const missingFiles = missingGuidanceFiles(projectDirectory);
   if (missingFiles.length === 0) {
-    console.log(import_picocolors.default.green(`
+    console.log(import_picocolors2.default.green(`
   ✔ DESIGN.md and AGENTS.md already exist; nothing was changed.
 `));
     return;
   }
   printGuidancePlan(projectDirectory, missingFiles);
   if (!write) {
-    console.log(import_picocolors.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
+    console.log(import_picocolors2.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
 `));
     return;
   }
   installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles);
-  console.log(import_picocolors.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
+  console.log(import_picocolors2.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
   console.log();
 }
 async function init() {
   console.log();
-  console.log(import_picocolors.default.cyan("  ╔═══════════════════════════════════╗"));
-  console.log(import_picocolors.default.cyan("  ║  ") + import_picocolors.default.bold("create-svadmin") + import_picocolors.default.cyan("                    ║"));
-  console.log(import_picocolors.default.cyan("  ║  ") + import_picocolors.default.dim("Headless Admin for Svelte 5") + import_picocolors.default.cyan("    ║"));
-  console.log(import_picocolors.default.cyan("  ╚═══════════════════════════════════╝"));
+  console.log(import_picocolors2.default.cyan("  ╔═══════════════════════════════════╗"));
+  console.log(import_picocolors2.default.cyan("  ║  ") + import_picocolors2.default.bold("create-svadmin") + import_picocolors2.default.cyan("                    ║"));
+  console.log(import_picocolors2.default.cyan("  ║  ") + import_picocolors2.default.dim("Headless Admin for Svelte 5") + import_picocolors2.default.cyan("    ║"));
+  console.log(import_picocolors2.default.cyan("  ╚═══════════════════════════════════╝"));
   console.log();
-  const response = await import_prompts.default([
+  const response = await import_prompts2.default([
     {
       type: "text",
       name: "projectName",
@@ -5575,7 +6879,7 @@ async function init() {
       validate: (value) => {
         if (!value.trim())
           return "Project name is required";
-        if (fs.existsSync(value.trim()) && fs.readdirSync(value.trim()).length > 0) {
+        if (fs2.existsSync(value.trim()) && fs2.readdirSync(value.trim()).length > 0) {
           return "Directory already exists and is not empty";
         }
         return true;
@@ -5613,61 +6917,61 @@ async function init() {
     }
   ]);
   if (!response.projectName) {
-    console.log(import_picocolors.default.red(`
+    console.log(import_picocolors2.default.red(`
 Operation cancelled.
 `));
     return;
   }
-  const projectDir = path.resolve(process.cwd(), response.projectName.trim());
-  if (!fs.existsSync(projectDir)) {
-    fs.mkdirSync(projectDir, { recursive: true });
+  const projectDir = path2.resolve(process.cwd(), response.projectName.trim());
+  if (!fs2.existsSync(projectDir)) {
+    fs2.mkdirSync(projectDir, { recursive: true });
   }
   console.log(`
-${import_picocolors.default.bold("Scaffolding")} project in ${import_picocolors.default.green(projectDir)}...
+${import_picocolors2.default.bold("Scaffolding")} project in ${import_picocolors2.default.green(projectDir)}...
 `);
-  const templateDir = path.join(__dirname2, "..", "template");
-  const guidanceDir = path.join(__dirname2, "..", "guidance");
+  const templateDir = path2.join(__dirname2, "..", "template");
+  const guidanceDir = path2.join(__dirname2, "..", "guidance");
   const scaffoldManifest = loadShippedScaffoldManifest();
   function copyDir(src, dest) {
-    fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
+    fs2.mkdirSync(dest, { recursive: true });
+    const entries = fs2.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
+      const srcPath = path2.join(src, entry.name);
+      const destPath = path2.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
-        fs.copyFileSync(srcPath, destPath);
+        fs2.copyFileSync(srcPath, destPath);
       }
     }
   }
-  if (fs.existsSync(templateDir)) {
+  if (fs2.existsSync(templateDir)) {
     copyDir(templateDir, projectDir);
-    console.log(import_picocolors.default.green("  ✔") + " Template files copied");
+    console.log(import_picocolors2.default.green("  ✔") + " Template files copied");
   }
-  if (fs.existsSync(guidanceDir)) {
+  if (fs2.existsSync(guidanceDir)) {
     copyDir(guidanceDir, projectDir);
-    console.log(import_picocolors.default.green("  ✔") + " AI and design guidance copied");
+    console.log(import_picocolors2.default.green("  ✔") + " AI and design guidance copied");
   }
   const packageJson = createProjectPackageJson(scaffoldManifest, {
     projectName: response.projectName,
     dataProvider: response.dataProvider,
     authProvider: response.authProvider
   });
-  fs.writeFileSync(path.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+  fs2.writeFileSync(path2.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
 `);
-  console.log(import_picocolors.default.green("  ✔") + " package.json generated");
-  fs.writeFileSync(path.join(projectDir, ".gitignore"), `node_modules
+  console.log(import_picocolors2.default.green("  ✔") + " package.json generated");
+  fs2.writeFileSync(path2.join(projectDir, ".gitignore"), `node_modules
 dist
 .svelte-kit
 .env
 .env.local
 *.local
 `);
-  console.log(import_picocolors.default.green("  ✔") + " .gitignore generated");
+  console.log(import_picocolors2.default.green("  ✔") + " .gitignore generated");
   const dpLabel = response.dataProvider === "simple-rest" ? "Simple REST" : response.dataProvider === "supabase" ? "Supabase" : response.dataProvider === "graphql" ? "GraphQL" : "Custom";
   const authLabel = response.authProvider === "mock" ? "Mock (demo)" : response.authProvider === "jwt" ? "JWT" : response.authProvider === "supabase" ? "Supabase Auth" : "None";
-  fs.writeFileSync(path.join(projectDir, "README.md"), `# ${response.projectName}
+  fs2.writeFileSync(path2.join(projectDir, "README.md"), `# ${response.projectName}
 
 Built with [svadmin](https://github.com/vibeunion/svadmin) — Headless Admin Framework for Svelte 5.
 
@@ -5685,30 +6989,30 @@ bun run dev
 - **Auth**: ${authLabel}
 - **State**: TanStack Query v6
 `);
-  console.log(import_picocolors.default.green("  ✔") + " README.md generated");
+  console.log(import_picocolors2.default.green("  ✔") + " README.md generated");
   if (response.installDeps) {
     console.log(`
-${import_picocolors.default.bold("Installing dependencies...")}
+${import_picocolors2.default.bold("Installing dependencies...")}
 `);
     const bunInstall = spawnSync("bun", ["install"], { cwd: projectDir, stdio: "inherit" });
     if (bunInstall.status !== 0) {
       const npmInstall = spawnSync("npm", ["install"], { cwd: projectDir, stdio: "inherit" });
       if (npmInstall.status !== 0) {
-        console.log(import_picocolors.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
+        console.log(import_picocolors2.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
       }
     }
   }
   console.log();
-  console.log(import_picocolors.default.green(import_picocolors.default.bold("  ✔ Project ready!")));
+  console.log(import_picocolors2.default.green(import_picocolors2.default.bold("  ✔ Project ready!")));
   console.log();
   console.log("  Next steps:");
-  console.log(`    ${import_picocolors.default.cyan(`cd ${response.projectName}`)}`);
+  console.log(`    ${import_picocolors2.default.cyan(`cd ${response.projectName}`)}`);
   if (!response.installDeps) {
-    console.log(`    ${import_picocolors.default.cyan("bun install")}`);
+    console.log(`    ${import_picocolors2.default.cyan("bun install")}`);
   }
-  console.log(`    ${import_picocolors.default.cyan("bun run dev")}`);
+  console.log(`    ${import_picocolors2.default.cyan("bun run dev")}`);
   console.log();
-  console.log(`  Docs: ${import_picocolors.default.blue("https://github.com/vibeunion/svadmin")}`);
+  console.log(`  Docs: ${import_picocolors2.default.blue("https://github.com/vibeunion/svadmin")}`);
   console.log();
 }
 var EJECT_COMPONENTS = [
@@ -5740,64 +7044,64 @@ var EJECT_COMPONENTS = [
 ];
 async function eject(args) {
   console.log();
-  console.log(import_picocolors.default.cyan("  svadmin eject") + import_picocolors.default.dim(" — copy internal components for deep customization"));
+  console.log(import_picocolors2.default.cyan("  svadmin eject") + import_picocolors2.default.dim(" — copy internal components for deep customization"));
   console.log();
   const requested = args.filter((a) => !a.startsWith("-"));
   const toEject = requested.length > 0 ? requested.filter((name) => {
     if (!EJECT_COMPONENTS.includes(name)) {
-      console.log(import_picocolors.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
+      console.log(import_picocolors2.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
       return false;
     }
     return true;
   }) : [...EJECT_COMPONENTS];
   if (toEject.length === 0) {
-    console.log(import_picocolors.default.red("  No valid components to eject."));
+    console.log(import_picocolors2.default.red("  No valid components to eject."));
     console.log(`  Available: ${EJECT_COMPONENTS.join(", ")}`);
     return;
   }
   let uiSrcDir;
   try {
     const require2 = createRequire2(import.meta.url);
-    const uiPkg = path.dirname(require2.resolve("@svadmin/ui/package.json"));
-    uiSrcDir = path.join(uiPkg, "src", "components");
+    const uiPkg = path2.dirname(require2.resolve("@svadmin/ui/package.json"));
+    uiSrcDir = path2.join(uiPkg, "src", "components");
   } catch {
-    const nm = path.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
-    if (fs.existsSync(nm)) {
+    const nm = path2.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
+    if (fs2.existsSync(nm)) {
       uiSrcDir = nm;
     } else {
-      console.log(import_picocolors.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
+      console.log(import_picocolors2.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
       return;
     }
   }
-  const destDir = path.join(process.cwd(), "src", "components", "svadmin");
-  fs.mkdirSync(destDir, { recursive: true });
+  const destDir = path2.join(process.cwd(), "src", "components", "svadmin");
+  fs2.mkdirSync(destDir, { recursive: true });
   let copied = 0;
   for (const name of toEject) {
-    const srcFile = path.join(uiSrcDir, `${name}.svelte`);
-    const srcFileAlt = path.join(uiSrcDir, "fields", `${name}.svelte`);
-    const src = fs.existsSync(srcFile) ? srcFile : fs.existsSync(srcFileAlt) ? srcFileAlt : null;
+    const srcFile = path2.join(uiSrcDir, `${name}.svelte`);
+    const srcFileAlt = path2.join(uiSrcDir, "fields", `${name}.svelte`);
+    const src = fs2.existsSync(srcFile) ? srcFile : fs2.existsSync(srcFileAlt) ? srcFileAlt : null;
     if (!src) {
-      console.log(import_picocolors.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
+      console.log(import_picocolors2.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
       continue;
     }
-    let content = fs.readFileSync(src, "utf-8");
+    let content = fs2.readFileSync(src, "utf-8");
     content = content.replace(/from\s+['"]\.\/ui\//g, "from '@svadmin/ui/components/ui/");
     content = content.replace(/from\s+['"]\.\/((?!ui\/)[^'"]+)['"]/g, "from './$1'");
-    const destFile = path.join(destDir, `${name}.svelte`);
-    fs.writeFileSync(destFile, content);
-    console.log(import_picocolors.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
+    const destFile = path2.join(destDir, `${name}.svelte`);
+    fs2.writeFileSync(destFile, content);
+    console.log(import_picocolors2.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
     copied++;
   }
   console.log();
   if (copied > 0) {
-    console.log(import_picocolors.default.green(import_picocolors.default.bold(`  ✔ Ejected ${copied} component(s)`)));
+    console.log(import_picocolors2.default.green(import_picocolors2.default.bold(`  ✔ Ejected ${copied} component(s)`)));
     console.log();
     console.log("  Usage: import overrides in your AdminApp and pass via `components` prop:");
     console.log();
-    console.log(import_picocolors.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
-    console.log(import_picocolors.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
+    console.log(import_picocolors2.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
+    console.log(import_picocolors2.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
   } else {
-    console.log(import_picocolors.default.yellow("  No components were ejected."));
+    console.log(import_picocolors2.default.yellow("  No components were ejected."));
   }
   console.log();
 }
@@ -5805,7 +7109,7 @@ var [, , subcommand, ...rest] = process.argv;
 var runCommand = (command) => {
   Promise.resolve().then(command).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(import_picocolors.default.red(`
+    console.error(import_picocolors2.default.red(`
   ✗ ${message}
 `));
     process.exitCode = 2;
@@ -5819,6 +7123,8 @@ if (subcommand === "eject") {
   runCommand(() => upgrade(rest));
 } else if (subcommand === "guidance") {
   runCommand(() => guidance(rest));
+} else if (subcommand === "infer") {
+  runCommand(() => inferCommand(rest));
 } else {
   runCommand(init);
 }