cmx-sdk 0.1.17 → 0.1.18

package/dist/cli.js

@@ -1,262 +1,69 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 
 // src/cli.ts
 import { Command } from "commander";
 import { config } from "dotenv";
 
-// src/core/date-reviver.ts
-var isoDateFormat = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
-function dateReviver(_key, value) {
-  if (typeof value === "string" && isoDateFormat.test(value)) {
-    return new Date(value);
-  }
-  return value;
-}
-
-// src/generated/sdk/endpoints/sdk.ts
-var getGetSchemaUrl = () => {
-  return `/api/v1/sdk/schema`;
-};
-var getSchema = async (options) => {
-  const res = await fetch(
-    getGetSchemaUrl(),
-    {
-      ...options,
-      method: "GET"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getGetManageCollectionsUrl = () => {
-  return `/api/v1/sdk/manage/collections`;
-};
-var getManageCollections = async (options) => {
-  const res = await fetch(
-    getGetManageCollectionsUrl(),
-    {
-      ...options,
-      method: "GET"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPostManageCollectionsUrl = () => {
-  return `/api/v1/sdk/manage/collections`;
-};
-var postManageCollections = async (createCollectionRequest, options) => {
-  const res = await fetch(
-    getPostManageCollectionsUrl(),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        createCollectionRequest
-      )
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPutManageCollectionsSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/collections/${slug}`;
-};
-var putManageCollectionsSlug = async (slug, updateCollectionRequest, options) => {
-  const res = await fetch(
-    getPutManageCollectionsSlugUrl(slug),
-    {
-      ...options,
-      method: "PUT",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        updateCollectionRequest
-      )
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getDeleteManageCollectionsSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/collections/${slug}`;
-};
-var deleteManageCollectionsSlug = async (slug, options) => {
-  const res = await fetch(
-    getDeleteManageCollectionsSlugUrl(slug),
-    {
-      ...options,
-      method: "DELETE"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getGetManageDataTypesUrl = () => {
-  return `/api/v1/sdk/manage/data-types`;
-};
-var getManageDataTypes = async (options) => {
-  const res = await fetch(
-    getGetManageDataTypesUrl(),
-    {
-      ...options,
-      method: "GET"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPostManageDataTypesUrl = () => {
-  return `/api/v1/sdk/manage/data-types`;
-};
-var postManageDataTypes = async (createDataTypeRequest, options) => {
-  const res = await fetch(
-    getPostManageDataTypesUrl(),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        createDataTypeRequest
-      )
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPutManageDataTypesSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/data-types/${slug}`;
-};
-var putManageDataTypesSlug = async (slug, updateDataTypeRequest, options) => {
-  const res = await fetch(
-    getPutManageDataTypesSlugUrl(slug),
-    {
-      ...options,
-      method: "PUT",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        updateDataTypeRequest
-      )
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getDeleteManageDataTypesSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/data-types/${slug}`;
-};
-var deleteManageDataTypesSlug = async (slug, options) => {
-  const res = await fetch(
-    getDeleteManageDataTypesSlugUrl(slug),
-    {
-      ...options,
-      method: "DELETE"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getGetManageComponentsUrl = () => {
-  return `/api/v1/sdk/manage/components`;
-};
-var getManageComponents = async (options) => {
-  const res = await fetch(
-    getGetManageComponentsUrl(),
-    {
-      ...options,
-      method: "GET"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getGetManageFormDefinitionsUrl = () => {
-  return `/api/v1/sdk/manage/form-definitions`;
-};
-var getManageFormDefinitions = async (options) => {
-  const res = await fetch(
-    getGetManageFormDefinitionsUrl(),
-    {
-      ...options,
-      method: "GET"
-    }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPostManageFormDefinitionsUrl = () => {
-  return `/api/v1/sdk/manage/form-definitions`;
-};
-var postManageFormDefinitions = async (createFormDefinitionRequest, options) => {
-  const res = await fetch(
-    getPostManageFormDefinitionsUrl(),
-    {
-      ...options,
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        createFormDefinitionRequest
-      )
+// src/commands/utils.ts
+import { readFileSync } from "fs";
+function readJsonInput(options) {
+  if (options.json) {
+    try {
+      return JSON.parse(options.json);
+    } catch {
+      console.error("Error: Invalid JSON string provided to --json");
+      process.exit(1);
     }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getPutManageFormDefinitionsSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/form-definitions/${slug}`;
-};
-var putManageFormDefinitionsSlug = async (slug, updateFormDefinitionRequest, options) => {
-  const res = await fetch(
-    getPutManageFormDefinitionsSlugUrl(slug),
-    {
-      ...options,
-      method: "PUT",
-      headers: { "Content-Type": "application/json", ...options?.headers },
-      body: JSON.stringify(
-        updateFormDefinitionRequest
-      )
+  }
+  if (options.file) {
+    try {
+      const content = readFileSync(options.file, "utf-8");
+      return JSON.parse(content);
+    } catch (err) {
+      console.error(`Error: Failed to read JSON file: ${options.file}`);
+      console.error(err instanceof Error ? err.message : err);
+      process.exit(1);
     }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
-var getDeleteManageFormDefinitionsSlugUrl = (slug) => {
-  return `/api/v1/sdk/manage/form-definitions/${slug}`;
-};
-var deleteManageFormDefinitionsSlug = async (slug, options) => {
-  const res = await fetch(
-    getDeleteManageFormDefinitionsSlugUrl(slug),
-    {
-      ...options,
-      method: "DELETE"
+  }
+  console.error("Error: --json or --file is required");
+  process.exit(1);
+}
+async function manageApiFetch(apiUrl, apiKey, method, path, body) {
+  const url = `${apiUrl}/api/v1/sdk/manage${path}`;
+  const response = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    ...body ? { body: JSON.stringify(body) } : {}
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    let errorMsg;
+    try {
+      const parsed = JSON.parse(errorBody);
+      errorMsg = parsed.error || errorBody;
+    } catch {
+      errorMsg = errorBody;
     }
-  );
-  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
-  const data = body ? JSON.parse(body, dateReviver) : {};
-  return { data, status: res.status, headers: res.headers };
-};
+    throw new Error(`API error (${response.status}): ${errorMsg}`);
+  }
+  return response.json();
+}
 
 // src/commands/list-collections.ts
 async function listCollections() {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     console.log("Fetching collections...");
-    const response = await getManageCollections();
-    const collections = Array.isArray(response.data) ? response.data : [];
-    if (collections.length === 0) {
+    const collections = await manageApiFetch(apiUrl, apiKey, "GET", "/collections");
+    if (!Array.isArray(collections) || collections.length === 0) {
       console.log("No collections found.");
       return;
     }
@@ -279,11 +86,16 @@ Found ${collections.length} collection(s):
 
 // src/commands/list-data-types.ts
 async function listDataTypes() {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     console.log("Fetching data types...");
-    const response = await getManageDataTypes();
-    const dataTypes = Array.isArray(response.data) ? response.data : [];
-    if (dataTypes.length === 0) {
+    const dataTypes = await manageApiFetch(apiUrl, apiKey, "GET", "/data-types");
+    if (!Array.isArray(dataTypes) || dataTypes.length === 0) {
       console.log("No data types found.");
       return;
     }
@@ -307,11 +119,16 @@ Found ${dataTypes.length} data type(s):
 
 // src/commands/list-forms.ts
 async function listForms() {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     console.log("Fetching form definitions...");
-    const response = await getManageFormDefinitions();
-    const forms = Array.isArray(response.data) ? response.data : [];
-    if (forms.length === 0) {
+    const forms = await manageApiFetch(apiUrl, apiKey, "GET", "/form-definitions");
+    if (!Array.isArray(forms) || forms.length === 0) {
       console.log("No form definitions found.");
       return;
     }
@@ -335,10 +152,16 @@ Found ${forms.length} form definition(s):
 
 // src/commands/list-components.ts
 async function listComponents() {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     console.log("Fetching custom components...");
-    const response = await getManageComponents();
-    const components = Array.isArray(response.data) ? response.data : [];
+    const result = await manageApiFetch(apiUrl, apiKey, "GET", "/components");
+    const components = Array.isArray(result) ? result : result.components || [];
     if (components.length === 0) {
       console.log("No custom components found.");
       return;
@@ -360,84 +183,66 @@ Found ${components.length} custom component(s):
   }
 }
 
-// src/commands/utils.ts
-import { readFileSync } from "fs";
-function readJsonInput(args) {
-  const jsonIdx = args.indexOf("--json");
-  const fileIdx = args.indexOf("--file");
-  if (jsonIdx !== -1 && args[jsonIdx + 1]) {
-    try {
-      return JSON.parse(args[jsonIdx + 1]);
-    } catch {
-      console.error("Error: Invalid JSON string provided to --json");
-      process.exit(1);
-    }
+// src/commands/create-collection.ts
+async function createCollection(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
   }
-  if (fileIdx !== -1 && args[fileIdx + 1]) {
-    try {
-      const content = readFileSync(args[fileIdx + 1], "utf-8");
-      return JSON.parse(content);
-    } catch (err) {
-      console.error(`Error: Failed to read JSON file: ${args[fileIdx + 1]}`);
-      console.error(err instanceof Error ? err.message : err);
+  let input;
+  if (options.json || options.file) {
+    input = readJsonInput(options);
+  } else {
+    if (!options.type || !options.slug || !options.name) {
+      console.error("Error: --json or --type, --slug, --name are required");
       process.exit(1);
     }
+    input = {
+      type: options.type,
+      slug: options.slug,
+      name: options.name,
+      description: options.description ?? void 0
+    };
   }
-  console.error("Error: --json or --file is required");
-  process.exit(1);
-}
-async function manageApiFetch(apiUrl, apiKey, method, path2, body) {
-  const url = `${apiUrl}/api/v1/sdk/manage${path2}`;
-  const response = await fetch(url, {
-    method,
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    ...body ? { body: JSON.stringify(body) } : {}
-  });
-  if (!response.ok) {
-    const errorBody = await response.text();
-    let errorMsg;
-    try {
-      const parsed = JSON.parse(errorBody);
-      errorMsg = parsed.error || errorBody;
-    } catch {
-      errorMsg = errorBody;
-    }
-    throw new Error(`API error (${response.status}): ${errorMsg}`);
-  }
-  return response.json();
-}
-
-// src/commands/create-collection.ts
-async function createCollection(args, apiUrl, apiKey) {
-  const input = readJsonInput(args);
   if (!input.type || !input.slug || !input.name) {
     console.error("Error: JSON must include type, slug, and name");
     process.exit(1);
   }
   console.log(`Creating collection: ${input.slug} (${input.type})...`);
-  const response = await postManageCollections(input);
+  const result = await manageApiFetch(apiUrl, apiKey, "POST", "/collections", input);
   console.log("Collection created successfully:");
-  console.log(JSON.stringify(response.data, null, 2));
+  console.log(JSON.stringify(result, null, 2));
 }
 
 // src/commands/create-data-type.ts
-async function createDataType(args, apiUrl, apiKey) {
-  const input = readJsonInput(args);
+async function createDataType(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const input = readJsonInput(options);
   if (!input.slug || !input.name || !input.fields) {
     console.error("Error: JSON must include slug, name, and fields");
     process.exit(1);
   }
   console.log(`Creating data type: ${input.slug}...`);
-  const response = await postManageDataTypes(input);
+  const result = await manageApiFetch(apiUrl, apiKey, "POST", "/data-types", input);
   console.log("Data type created successfully:");
-  console.log(JSON.stringify(response.data, null, 2));
+  console.log(JSON.stringify(result, null, 2));
 }
 
 // src/commands/create-form.ts
 async function createForm(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     let data;
     if (options.json) {
@@ -451,13 +256,12 @@ async function createForm(options) {
         name: options.name,
         description: options.description,
         fields: []
-        // JSONでフィールドを指定する必要がある
       };
     }
     console.log(`Creating form definition: ${data.name} (${data.slug})...`);
-    const response = await postManageFormDefinitions(data);
+    const result = await manageApiFetch(apiUrl, apiKey, "POST", "/form-definitions", data);
     console.log("\u2713 Form definition created successfully");
-    console.log(JSON.stringify(response.data, null, 2));
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
     console.error("\u2717 Failed to create form definition:");
     console.error(error instanceof Error ? error.message : String(error));
@@ -467,6 +271,12 @@ async function createForm(options) {
 
 // src/commands/update-collection.ts
 async function updateCollection(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required (the current slug of the collection to update)");
@@ -484,7 +294,7 @@ async function updateCollection(options) {
       throw new Error("No fields to update. Provide --json, --new-slug, --name, or --description");
     }
     console.log(`Updating collection: ${options.slug}...`);
-    const result = await putManageCollectionsSlug(options.slug, data);
+    const result = await manageApiFetch(apiUrl, apiKey, "PUT", `/collections/${options.slug}`, data);
     console.log("\u2713 Collection updated successfully");
     console.log(JSON.stringify(result, null, 2));
   } catch (error) {
@@ -496,6 +306,12 @@ async function updateCollection(options) {
 
 // src/commands/update-data-type.ts
 async function updateDataType(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required (the current slug of the data type to update)");
@@ -513,7 +329,7 @@ async function updateDataType(options) {
       throw new Error("No fields to update. Provide --json, --new-slug, --name, or --description");
     }
     console.log(`Updating data type: ${options.slug}...`);
-    const result = await putManageDataTypesSlug(options.slug, data);
+    const result = await manageApiFetch(apiUrl, apiKey, "PUT", `/data-types/${options.slug}`, data);
     console.log("\u2713 Data type updated successfully");
     console.log(JSON.stringify(result, null, 2));
   } catch (error) {
@@ -525,6 +341,12 @@ async function updateDataType(options) {
 
 // src/commands/update-form.ts
 async function updateForm(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required (the current slug of the form to update)");
@@ -542,7 +364,7 @@ async function updateForm(options) {
       throw new Error("No fields to update. Provide --json, --new-slug, --name, or --description");
     }
     console.log(`Updating form: ${options.slug}...`);
-    const result = await putManageFormDefinitionsSlug(options.slug, data);
+    const result = await manageApiFetch(apiUrl, apiKey, "PUT", `/form-definitions/${options.slug}`, data);
     console.log("\u2713 Form updated successfully");
     console.log(JSON.stringify(result, null, 2));
   } catch (error) {
@@ -559,14 +381,20 @@ async function confirm(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
 async function deleteCollection(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required");
@@ -582,7 +410,7 @@ async function deleteCollection(options) {
       }
     }
     console.log(`Deleting collection: ${options.slug}...`);
-    await deleteManageCollectionsSlug(options.slug);
+    await manageApiFetch(apiUrl, apiKey, "DELETE", `/collections/${options.slug}`);
     console.log("\u2713 Collection deleted successfully");
   } catch (error) {
     console.error("\u2717 Failed to delete collection:");
@@ -598,14 +426,20 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
 async function deleteDataType(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required");
@@ -621,7 +455,7 @@ async function deleteDataType(options) {
       }
     }
     console.log(`Deleting data type: ${options.slug}...`);
-    await deleteManageDataTypesSlug(options.slug);
+    await manageApiFetch(apiUrl, apiKey, "DELETE", `/data-types/${options.slug}`);
     console.log("\u2713 Data type deleted successfully");
   } catch (error) {
     console.error("\u2717 Failed to delete data type:");
@@ -637,14 +471,20 @@ async function confirm3(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
 async function deleteForm(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
   try {
     if (!options.slug) {
       throw new Error("--slug is required");
@@ -661,7 +501,7 @@ async function deleteForm(options) {
       }
     }
     console.log(`Deleting form: ${options.slug}...`);
-    await deleteManageFormDefinitionsSlug(options.slug);
+    await manageApiFetch(apiUrl, apiKey, "DELETE", `/form-definitions/${options.slug}`);
     console.log("\u2713 Form deleted successfully");
   } catch (error) {
     console.error("\u2717 Failed to delete form:");
@@ -674,10 +514,6 @@ async function deleteForm(options) {
 import { readdirSync, readFileSync as readFileSync2, existsSync } from "fs";
 import { join } from "path";
 import { execSync } from "child_process";
-function parseArg(args, flag) {
-  const idx = args.indexOf(flag);
-  return idx !== -1 && args[idx + 1] ? args[idx + 1] : void 0;
-}
 function detectEnvironment() {
   try {
     const branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
@@ -731,8 +567,14 @@ function readComponentDefinitions(componentsDir, environment) {
   }
   return components;
 }
-async function syncComponents(args, apiUrl, apiKey) {
-  const environment = parseArg(args, "--environment") || detectEnvironment();
+async function syncComponents(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const environment = options.environment || detectEnvironment();
   const componentsDir = join(process.cwd(), "cmx/components");
   console.log(`Environment: ${environment}`);
   const components = readComponentDefinitions(componentsDir, environment);
@@ -757,158 +599,1058 @@ async function syncComponents(args, apiUrl, apiKey) {
   if (result.updated) console.log(`  Updated: ${result.updated}`);
 }
 
-// src/commands/generate.ts
-import * as fs from "fs";
-import * as path from "path";
-function mapFieldType(field) {
-  const baseType = (() => {
-    switch (field.type) {
-      case "text":
-      case "textarea":
-      case "richtext":
-      case "markdown":
-      case "email":
-      case "url":
-      case "slug":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-      case "checkbox":
-        return "boolean";
-      case "date":
-      case "datetime":
-        return "string";
-      // ISO 8601 string
-      case "select":
-      case "radio":
-        return "string";
-      case "image":
-      case "file":
-        return "string";
-      // URL
-      case "relation":
-        return "string";
-      // ID or slug
-      default:
-        return "unknown";
-    }
-  })();
-  return field.required ? baseType : `${baseType} | null`;
+// src/codegen/generator.ts
+import { mkdir, writeFile, rm } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/codegen/fetch-schema.ts
+async function fetchSchema(apiUrl, apiKey) {
+  const url = `${apiUrl.replace(/\/$/, "")}/api/v1/sdk/schema`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Failed to fetch schema (HTTP ${response.status}): ${body}`);
+  }
+  return response.json();
+}
+
+// src/codegen/naming.ts
+function slugToPascalCase(slug) {
+  return slug.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+function slugToCamelCase(slug) {
+  const pascal = slugToPascalCase(slug);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function singularize(name) {
+  if (name.endsWith("ies")) {
+    return name.slice(0, -3) + "y";
+  }
+  if (name.endsWith("ses") || name.endsWith("xes") || name.endsWith("zes")) {
+    return name.slice(0, -2);
+  }
+  if (name.endsWith("s") && !name.endsWith("ss")) {
+    return name.slice(0, -1);
+  }
+  return name;
+}
+function sanitizeIdentifier(slug) {
+  const cleaned = slug.replace(/[^a-zA-Z0-9-]/g, "");
+  if (/^[0-9]/.test(cleaned)) {
+    return "_" + cleaned;
+  }
+  return cleaned;
+}
+function escapeTs(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
+function createNameTracker() {
+  const used = /* @__PURE__ */ new Set();
+  return function getUniqueName(name) {
+    let candidate = name;
+    let counter = 1;
+    while (used.has(candidate)) {
+      candidate = `${name}${counter}`;
+      counter++;
+    }
+    used.add(candidate);
+    return candidate;
+  };
+}
+
+// src/codegen/type-map.ts
+function fieldToTsType(field) {
+  const baseType = getBaseType(field);
+  if (!field.required) {
+    return `${baseType} | null`;
+  }
+  return baseType;
+}
+function getBaseType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richtext":
+    case "url":
+    case "email":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+      return "string";
+    case "select":
+      if (field.options?.choices && field.options.choices.length > 0) {
+        return field.options.choices.map((c) => `"${c.value}"`).join(" | ");
+      }
+      return "string";
+    case "multiselect":
+      if (field.options?.choices && field.options.choices.length > 0) {
+        return `(${field.options.choices.map((c) => `"${c.value}"`).join(" | ")})[]`;
+      }
+      return "string[]";
+    case "image":
+    case "file":
+      return "string";
+    case "relation":
+      if (field.options?.multiple) {
+        return "string[]";
+      }
+      return "string";
+    case "json":
+      return "unknown";
+    default:
+      return "unknown";
+  }
 }
+
+// src/codegen/generate-data-type.ts
 function generateDataTypeFile(dataType) {
-  const interfaceName = toPascalCase(dataType.slug);
-  const fields = dataType.fields.map((field) => {
-    const comment = field.description ? `/** ${field.label} - ${field.description} */` : `/** ${field.label} */`;
-    return `  ${comment}
-  ${field.key}: ${mapFieldType(field)}`;
-  }).join("\n");
-  return `// Auto-generated by cmx-sdk generate
-// Data Type: ${dataType.name} (${dataType.slug})
-// Do not edit manually.
+  const safeSlug = sanitizeIdentifier(dataType.slug);
+  const pascalPlural = slugToPascalCase(safeSlug);
+  const interfaceName = singularize(pascalPlural);
+  const slug = dataType.slug;
+  const lines = [];
+  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Data Type: ${dataType.name} (${slug})`);
+  lines.push(`// Do not edit manually.`);
+  lines.push(``);
+  lines.push(`import { getDataEntries, getDataEntry } from "cmx-sdk"`);
+  lines.push(``);
+  lines.push(`export interface ${interfaceName} {`);
+  for (const field of dataType.fields) {
+    const tsType = fieldToTsType(field);
+    const docParts = [];
+    if (field.label) docParts.push(field.label);
+    if (field.description) docParts.push(field.description);
+    if (docParts.length > 0) {
+      lines.push(`  /** ${docParts.join(" - ")} */`);
+    }
+    lines.push(`  ${field.key}: ${tsType}`);
+  }
+  lines.push(`  _meta: {`);
+  lines.push(`    sortOrder: number`);
+  lines.push(`    createdAt: string`);
+  lines.push(`    updatedAt: string`);
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push(``);
+  const getAllFnName = `get${pascalPlural}`;
+  lines.push(`export async function ${getAllFnName}(options?: {`);
+  lines.push(`  sortBy?: string`);
+  lines.push(`  sortOrder?: string`);
+  lines.push(`  limit?: number`);
+  lines.push(`  offset?: number`);
+  lines.push(`}): Promise<{ type: string; items: ${interfaceName}[]; count: number }> {`);
+  lines.push(`  const result = await getDataEntries("${slug}", options)`);
+  lines.push(
+    `  return result as unknown as { type: string; items: ${interfaceName}[]; count: number }`
+  );
+  lines.push(`}`);
+  lines.push(``);
+  const getOneFnName = `get${interfaceName}ById`;
+  lines.push(
+    `export async function ${getOneFnName}(id: string): Promise<${interfaceName}> {`
+  );
+  lines.push(`  const result = await getDataEntry("${slug}", id)`);
+  lines.push(`  return result as unknown as ${interfaceName}`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
 
-import { getDataEntries, getDataEntry } from "cmx-sdk"
+// src/codegen/generate-collection.ts
+function generateCollectionFile(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const slug = collection.slug;
+  const lines = [];
+  const escapedName = escapeTs(collection.name);
+  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Collection: ${escapedName} (${slug})`);
+  lines.push(`// Do not edit manually.`);
+  lines.push(``);
+  lines.push(
+    `import { getCollectionContents, getCollectionContentDetail } from "cmx-sdk"`
+  );
+  lines.push(
+    `import type { CollectionContentsResponse, CollectionContentDetailResponse } from "cmx-sdk"`
+  );
+  lines.push(``);
+  lines.push(
+    `export async function get${pascal}Contents(): Promise<CollectionContentsResponse> {`
+  );
+  lines.push(`  return getCollectionContents("${escapeTs(slug)}")`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(
+    `export async function get${pascal}ContentDetail(slug: string): Promise<CollectionContentDetailResponse> {`
+  );
+  lines.push(`  return getCollectionContentDetail("${escapeTs(slug)}", slug)`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
 
-export interface ${interfaceName} {
-${fields}
-  _meta: {
-    sortOrder: number
-    createdAt: string
-    updatedAt: string
+// src/codegen/zod-map.ts
+function fieldToZodType(field) {
+  const base = getBaseZodType(field);
+  if (!field.required) {
+    return `${base}.optional()`;
+  }
+  return base;
+}
+function getBaseZodType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richtext":
+      return field.required ? `z.string().min(1, "${escapeTs(field.label)}\u306F\u5FC5\u9808\u3067\u3059")` : `z.string()`;
+    case "email":
+      return `z.string().email("\u6709\u52B9\u306A\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044")`;
+    case "url":
+      return `z.string().url("\u6709\u52B9\u306AURL\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044")`;
+    case "number":
+      return `z.number()`;
+    case "boolean":
+      return `z.boolean()`;
+    case "date":
+    case "datetime":
+      return `z.string()`;
+    case "select":
+      if (field.options?.choices && field.options.choices.length > 0) {
+        const values = field.options.choices.map((c) => `"${escapeTs(c.value)}"`).join(", ");
+        return `z.enum([${values}])`;
+      }
+      return `z.string()`;
+    case "multiselect":
+      if (field.options?.choices && field.options.choices.length > 0) {
+        const values = field.options.choices.map((c) => `"${escapeTs(c.value)}"`).join(", ");
+        return `z.array(z.enum([${values}]))`;
+      }
+      return `z.array(z.string())`;
+    case "image":
+    case "file":
+      return `z.string()`;
+    case "relation":
+      if (field.options?.multiple) {
+        return `z.array(z.string())`;
+      }
+      return `z.string()`;
+    case "json":
+      return `z.unknown()`;
+    default:
+      return `z.unknown()`;
   }
 }
 
-export async function get${interfaceName}(options?: {
-  sortBy?: string
-  sortOrder?: string
-  limit?: number
-  offset?: number
-}): Promise<{ type: string; items: ${interfaceName}[]; count: number }> {
-  const result = await getDataEntries("${dataType.slug}", options)
-  return result as unknown as { type: string; items: ${interfaceName}[]; count: number }
+// src/codegen/generate-form.ts
+function generateFormFile(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const camel = slugToCamelCase(safeSlug);
+  const slug = form.slug;
+  const lines = [];
+  const escapedName = escapeTs(form.name);
+  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Form: ${escapedName} (${slug})`);
+  lines.push(`// Do not edit manually.`);
+  lines.push(``);
+  lines.push(`import { z } from "zod"`);
+  lines.push(`import { submitFormData } from "cmx-sdk"`);
+  lines.push(``);
+  lines.push(`export const ${camel}Schema = z.object({`);
+  for (const field of form.fields) {
+    const zodType = fieldToZodType(field);
+    if (field.label) {
+      lines.push(`  /** ${field.label.replace(/\*\//g, "* /")} */`);
+    }
+    lines.push(`  ${field.key}: ${zodType},`);
+  }
+  lines.push(`})`);
+  lines.push(``);
+  lines.push(`export type ${pascal}FormData = z.infer<typeof ${camel}Schema>`);
+  lines.push(``);
+  lines.push(
+    `export async function submit${pascal}(data: ${pascal}FormData): Promise<{ success: true; id: string }> {`
+  );
+  lines.push(`  const validated = ${camel}Schema.parse(data)`);
+  lines.push(`  return submitFormData("${escapeTs(slug)}", validated)`);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
 }
 
-export async function get${interfaceName}ById(id: string): Promise<${interfaceName}> {
-  const result = await getDataEntry("${dataType.slug}", id)
-  return result as unknown as ${interfaceName}
+// src/codegen/generate-index.ts
+function generateDataTypesIndex(slugs) {
+  const lines = [
+    `// Auto-generated by cmx-sdk generate`,
+    `// Do not edit manually.`,
+    ``
+  ];
+  for (const slug of slugs) {
+    lines.push(`export * from "./${slug}"`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateCollectionsIndex(slugs) {
+  const lines = [
+    `// Auto-generated by cmx-sdk generate`,
+    `// Do not edit manually.`,
+    ``
+  ];
+  for (const slug of slugs) {
+    lines.push(`export * from "./${slug}"`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateFormsIndex(slugs) {
+  const lines = [
+    `// Auto-generated by cmx-sdk generate`,
+    `// Do not edit manually.`,
+    ``
+  ];
+  for (const slug of slugs) {
+    lines.push(`export * from "./${slug}"`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateRootIndex(hasDataTypes, hasCollections, hasForms) {
+  const lines = [
+    `// Auto-generated by cmx-sdk generate`,
+    `// Do not edit manually.`,
+    ``
+  ];
+  if (hasDataTypes) {
+    lines.push(`export * from "./data-types"`);
+  }
+  if (hasCollections) {
+    lines.push(`export * from "./collections"`);
+  }
+  if (hasForms) {
+    lines.push(`export * from "./forms"`);
+  }
+  lines.push(``);
+  return lines.join("\n");
+}
+
+// src/codegen/generator.ts
+async function generate(options) {
+  const { apiUrl, apiKey, outputDir } = options;
+  console.log(`Fetching schema from ${apiUrl} ...`);
+  const schema = await fetchSchema(apiUrl, apiKey);
+  const forms = schema.forms ?? [];
+  console.log(
+    `Found ${schema.dataTypes.length} data type(s), ${schema.collections.length} collection(s), and ${forms.length} form(s)`
+  );
+  await rm(outputDir, { recursive: true, force: true });
+  await mkdir(outputDir, { recursive: true });
+  const dataTypeSlugs = [];
+  const collectionSlugs = [];
+  const formSlugs = [];
+  if (schema.dataTypes.length > 0) {
+    const dataTypesDir = join2(outputDir, "data-types");
+    await mkdir(dataTypesDir, { recursive: true });
+    const nameTracker = createNameTracker();
+    for (const dt of schema.dataTypes) {
+      const safeSlug = sanitizeIdentifier(dt.slug);
+      if (!safeSlug) {
+        console.warn(`  Skipping data type with invalid slug: "${dt.slug}"`);
+        continue;
+      }
+      const fileName = nameTracker(safeSlug);
+      const content = generateDataTypeFile(dt);
+      await writeFile(join2(dataTypesDir, `${fileName}.ts`), content, "utf-8");
+      dataTypeSlugs.push(fileName);
+      console.log(`  Generated data-types/${fileName}.ts (${dt.name})`);
+    }
+    const indexContent = generateDataTypesIndex(dataTypeSlugs);
+    await writeFile(join2(dataTypesDir, "index.ts"), indexContent, "utf-8");
+  }
+  if (schema.collections.length > 0) {
+    const collectionsDir = join2(outputDir, "collections");
+    await mkdir(collectionsDir, { recursive: true });
+    const nameTracker = createNameTracker();
+    for (const col of schema.collections) {
+      const safeSlug = sanitizeIdentifier(col.slug);
+      if (!safeSlug) {
+        console.warn(`  Skipping collection with invalid slug: "${col.slug}"`);
+        continue;
+      }
+      const fileName = nameTracker(safeSlug);
+      const content = generateCollectionFile(col);
+      await writeFile(join2(collectionsDir, `${fileName}.ts`), content, "utf-8");
+      collectionSlugs.push(fileName);
+      console.log(`  Generated collections/${fileName}.ts (${col.name})`);
+    }
+    const indexContent = generateCollectionsIndex(collectionSlugs);
+    await writeFile(join2(collectionsDir, "index.ts"), indexContent, "utf-8");
+  }
+  if (forms.length > 0) {
+    const formsDir = join2(outputDir, "forms");
+    await mkdir(formsDir, { recursive: true });
+    const nameTracker = createNameTracker();
+    for (const form of forms) {
+      const safeSlug = sanitizeIdentifier(form.slug);
+      if (!safeSlug) {
+        console.warn(`  Skipping form with invalid slug: "${form.slug}"`);
+        continue;
+      }
+      const fileName = nameTracker(safeSlug);
+      const content = generateFormFile(form);
+      await writeFile(join2(formsDir, `${fileName}.ts`), content, "utf-8");
+      formSlugs.push(fileName);
+      console.log(`  Generated forms/${fileName}.ts (${form.name})`);
+    }
+    const indexContent = generateFormsIndex(formSlugs);
+    await writeFile(join2(formsDir, "index.ts"), indexContent, "utf-8");
+  }
+  const rootIndex = generateRootIndex(
+    dataTypeSlugs.length > 0,
+    collectionSlugs.length > 0,
+    formSlugs.length > 0
+  );
+  await writeFile(join2(outputDir, "index.ts"), rootIndex, "utf-8");
+  console.log(`
+Generated files in ${outputDir}`);
+}
+
+// src/commands/list-collection-data-types.ts
+async function listCollectionDataTypes(opts) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const collectionSlug = opts.collection;
+  if (!collectionSlug) {
+    console.error("Error: --collection is required");
+    process.exit(1);
+  }
+  try {
+    console.log(`Fetching data types for collection: ${collectionSlug}...`);
+    const dataTypes = await manageApiFetch(
+      apiUrl,
+      apiKey,
+      "GET",
+      `/collections/${collectionSlug}/data-types`
+    );
+    if (dataTypes.length === 0) {
+      console.log("No data types found for this collection.");
+      return;
+    }
+    console.log(`
+Found ${dataTypes.length} data type(s):
+`);
+    dataTypes.forEach((dt) => {
+      console.log(`  ${dt.name} (${dt.slug})`);
+      if (dt.description) {
+        console.log(`    Description: ${dt.description}`);
+      }
+      console.log(`    Fields: ${dt.fields?.length || 0}`);
+      console.log();
+    });
+  } catch (error) {
+    console.error("\u2717 Failed to list collection data types:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/add-collection-data-type.ts
+async function addCollectionDataType(opts) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const collectionSlug = opts.collection;
+  if (!collectionSlug) {
+    console.error("Error: --collection is required");
+    process.exit(1);
+  }
+  try {
+    let input;
+    if (opts.preset) {
+      input = { presetSlug: opts.preset };
+    } else if (opts.json || opts.file) {
+      input = readJsonInput(opts);
+    } else {
+      console.error("Error: --preset or --json/--file is required");
+      process.exit(1);
+    }
+    console.log(`Adding data type to collection: ${collectionSlug}...`);
+    const result = await manageApiFetch(
+      apiUrl,
+      apiKey,
+      "POST",
+      `/collections/${collectionSlug}/data-types`,
+      input
+    );
+    console.log("Data type added successfully:");
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error("\u2717 Failed to add collection data type:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/remove-collection-data-type.ts
+async function removeCollectionDataType(opts) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const collectionSlug = opts.collection;
+  if (!collectionSlug) {
+    console.error("Error: --collection is required");
+    process.exit(1);
+  }
+  if (!opts.dataType) {
+    console.error("Error: --data-type is required");
+    process.exit(1);
+  }
+  try {
+    console.log(`Removing data type "${opts.dataType}" from collection: ${collectionSlug}...`);
+    await manageApiFetch(
+      apiUrl,
+      apiKey,
+      "DELETE",
+      `/collections/${collectionSlug}/data-types/${opts.dataType}`
+    );
+    console.log("Data type removed successfully.");
+  } catch (error) {
+    console.error("\u2717 Failed to remove collection data type:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/list-collection-presets.ts
+async function listCollectionPresets(opts) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  try {
+    const query = opts.type ? `?type=${opts.type}` : "";
+    console.log(opts.type ? `Fetching presets for type: ${opts.type}...` : "Fetching all presets...");
+    const result = await manageApiFetch(
+      apiUrl,
+      apiKey,
+      "GET",
+      `/collection-presets${query}`
+    );
+    if (opts.type && result.recommended) {
+      console.log(`
+Recommended presets for "${opts.type}":
+`);
+      result.recommended.forEach((p) => {
+        const defaultMark = p.default ? " [default]" : "";
+        console.log(`  ${p.name} (${p.slug})${defaultMark}`);
+        console.log(`    Type: ${p.referenceType}, Hierarchical: ${p.hierarchical}`);
+        console.log(`    Fields: ${p.fields.map((f) => f.key).join(", ")}`);
+        console.log();
+      });
+      if (result.others && result.others.length > 0) {
+        console.log("Other available presets:\n");
+        result.others.forEach((p) => {
+          console.log(`  ${p.name} (${p.slug})`);
+          console.log();
+        });
+      }
+    } else if (result.all) {
+      console.log(`
+Found ${result.all.length} preset(s):
+`);
+      result.all.forEach((p) => {
+        console.log(`  ${p.name} (${p.slug})`);
+        console.log(`    Type: ${p.referenceType}, Hierarchical: ${p.hierarchical}`);
+        console.log(`    Fields: ${p.fields.map((f) => f.key).join(", ")}`);
+        console.log();
+      });
+    } else {
+      console.log("No presets found.");
+    }
+  } catch (error) {
+    console.error("\u2717 Failed to list presets:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/link-collection-data-type.ts
+async function linkCollectionDataType(opts) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  const collectionSlug = opts.collection;
+  if (!collectionSlug) {
+    console.error("Error: --collection is required");
+    process.exit(1);
+  }
+  if (!opts.dataType) {
+    console.error("Error: --data-type is required");
+    process.exit(1);
+  }
+  if (!opts.fieldSlug) {
+    console.error("Error: --field-slug is required");
+    process.exit(1);
+  }
+  if (!opts.label) {
+    console.error("Error: --label is required");
+    process.exit(1);
+  }
+  const referenceType = opts.referenceType || "single";
+  if (referenceType !== "single" && referenceType !== "multiple") {
+    console.error("Error: --reference-type must be 'single' or 'multiple'");
+    process.exit(1);
+  }
+  try {
+    console.log(`Linking global data type "${opts.dataType}" to collection "${collectionSlug}"...`);
+    const result = await manageApiFetch(
+      apiUrl,
+      apiKey,
+      "POST",
+      `/collections/${collectionSlug}/data-types/link`,
+      {
+        dataTypeSlug: opts.dataType,
+        fieldSlug: opts.fieldSlug,
+        label: opts.label,
+        referenceType
+      }
+    );
+    console.log("Global data type linked successfully:");
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error("\u2717 Failed to link global data type:");
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/codegen/scaffolder.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3, dirname, resolve } from "path";
+
+// src/codegen/scaffold-collection.ts
+function scaffoldCollectionListPage(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const escapedName = escapeTs(collection.name);
+  const escapedDescription = escapeTs(collection.description ?? `${collection.name}\u306E\u4E00\u89A7`);
+  return `import { get${pascal}Contents } from "@/cmx/generated"
+import Link from "next/link"
+import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapedName}",
+  description: "${escapedDescription}",
+}
+
+export default async function ${pascal}Page() {
+  const { contents } = await get${pascal}Contents()
+
+  return (
+    <main>
+      <h1>${escapedName}</h1>
+      <ul>
+        {contents.map((item) => (
+          <li key={item.id}>
+            <Link href="/${safeSlug}/\${item.slug}">
+              <h2>{item.title}</h2>
+              {item.description && <p>{item.description}</p>}
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </main>
+  )
 }
 `;
 }
-function generateCollectionFile(collection) {
-  const functionPrefix = toPascalCase(collection.slug);
-  return `// Auto-generated by cmx-sdk generate
-// Collection: ${collection.name} (${collection.slug})
-// Do not edit manually.
+function scaffoldCollectionDetailPage(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import { get${pascal}Contents, get${pascal}ContentDetail } from "@/cmx/generated"
+import { renderMdx } from "cmx-sdk"
+import type { Metadata } from "next"
+
+type Props = {
+  params: Promise<{ slug: string }>
+}
 
-import { getCollectionContents, getCollectionContentDetail } from "cmx-sdk"
-import type { CollectionContentsResponse, CollectionContentDetailResponse } from "cmx-sdk"
+export async function generateStaticParams() {
+  const { contents } = await get${pascal}Contents()
+  return contents.map((item) => ({ slug: item.slug }))
+}
 
-export async function get${functionPrefix}Contents(): Promise<CollectionContentsResponse> {
-  return getCollectionContents("${collection.slug}")
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { slug } = await params
+  const { content } = await get${pascal}ContentDetail(slug)
+  return {
+    title: content.title,
+    description: content.description ?? undefined,
+  }
 }
 
-export async function get${functionPrefix}ContentDetail(slug: string): Promise<CollectionContentDetailResponse> {
-  return getCollectionContentDetail("${collection.slug}", slug)
+export default async function ${pascal}DetailPage({ params }: Props) {
+  const { slug } = await params
+  const { content, references } = await get${pascal}ContentDetail(slug)
+  const { content: rendered } = await renderMdx(content.mdx, references)
+
+  return (
+    <main>
+      <article>
+        <h1>{content.title}</h1>
+        {rendered}
+      </article>
+    </main>
+  )
 }
 `;
 }
-function toPascalCase(str) {
-  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+
+// src/codegen/scaffold-data-type.ts
+function scaffoldDataTypePage(dataType) {
+  const safeSlug = sanitizeIdentifier(dataType.slug);
+  const pascalPlural = slugToPascalCase(safeSlug);
+  const interfaceName = singularize(pascalPlural);
+  const slug = dataType.slug;
+  const fieldComments = dataType.fields.map((f) => `//   ${f.key}: ${f.type}${f.required ? "" : " (optional)"}`).join("\n");
+  return `import { get${pascalPlural} } from "@/cmx/generated"
+import type { ${interfaceName} } from "@/cmx/generated"
+import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapeTs(dataType.name)}",
+}
+
+// Available fields:
+${fieldComments}
+
+export default async function ${pascalPlural}Page() {
+  const { items } = await get${pascalPlural}()
+
+  return (
+    <main>
+      <h1>${escapeTs(dataType.name)}</h1>
+      <ul>
+        {items.map((item: ${interfaceName}, index: number) => (
+          <li key={index}>
+            {/* TODO: Customize the display for each item */}
+            <pre>{JSON.stringify(item, null, 2)}</pre>
+          </li>
+        ))}
+      </ul>
+    </main>
+  )
 }
-async function generate(options) {
-  const outputDir = options.output || "cmx/generated";
-  try {
-    console.log("Fetching schema from CMX API...");
-    const response = await getSchema();
-    const schema = response.data;
-    console.log(`Found ${schema.collections.length} collections and ${schema.dataTypes.length} data types`);
-    const collectionsDir = path.join(outputDir, "collections");
-    const dataTypesDir = path.join(outputDir, "data-types");
-    fs.mkdirSync(collectionsDir, { recursive: true });
-    fs.mkdirSync(dataTypesDir, { recursive: true });
-    for (const collection of schema.collections) {
-      const filePath = path.join(collectionsDir, `${collection.slug}.ts`);
-      const content = generateCollectionFile(collection);
-      fs.writeFileSync(filePath, content, "utf-8");
-      console.log(`\u2713 Generated ${filePath}`);
-    }
-    const collectionIndexContent = `// Auto-generated by cmx-sdk generate
-// Do not edit manually.
-
-${schema.collections.map((c) => `export * from "./${c.slug}"`).join("\n")}
 `;
-    fs.writeFileSync(path.join(collectionsDir, "index.ts"), collectionIndexContent, "utf-8");
-    console.log(`\u2713 Generated ${path.join(collectionsDir, "index.ts")}`);
-    for (const dataType of schema.dataTypes) {
-      const filePath = path.join(dataTypesDir, `${dataType.slug}.ts`);
-      const content = generateDataTypeFile(dataType);
-      fs.writeFileSync(filePath, content, "utf-8");
-      console.log(`\u2713 Generated ${filePath}`);
-    }
-    const dataTypesIndexContent = `// Auto-generated by cmx-sdk generate
-// Do not edit manually.
-
-${schema.dataTypes.map((dt) => `export * from "./${dt.slug}"`).join("\n")}
+}
+
+// src/codegen/scaffold-form.ts
+function scaffoldFormPage(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const camel = slugToCamelCase(safeSlug);
+  return `import { ${pascal}Form } from "./_components/${safeSlug}-form"
+import { ${camel}Schema, submit${pascal} } from "@/cmx/generated"
+import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapeTs(form.name)}",
+}
+
+async function handleSubmit(data: Record<string, unknown>) {
+  "use server"
+  const validated = ${camel}Schema.parse(data)
+  return submit${pascal}(validated)
+}
+
+export default function ${pascal}Page() {
+  return (
+    <main>
+      <h1>${escapeTs(form.name)}</h1>
+      <${pascal}Form action={handleSubmit} />
+    </main>
+  )
+}
 `;
-    fs.writeFileSync(path.join(dataTypesDir, "index.ts"), dataTypesIndexContent, "utf-8");
-    console.log(`\u2713 Generated ${path.join(dataTypesDir, "index.ts")}`);
-    const mainIndexContent = `// Auto-generated by cmx-sdk generate
-// Do not edit manually.
+}
+function scaffoldFormComponent(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const camel = slugToCamelCase(safeSlug);
+  const inputFields = form.fields.map((field) => {
+    const inputType = getInputType(field.type);
+    const required = field.required ? " required" : "";
+    const escapedLabel = escapeTs(field.label);
+    return `          <div>
+            <label htmlFor="${field.key}">${escapedLabel}</label>
+            <input
+              id="${field.key}"
+              type="${inputType}"
+              {...register("${field.key}")}${required}
+            />
+            {errors.${field.key} && (
+              <p role="alert">{errors.${field.key}?.message}</p>
+            )}
+          </div>`;
+  }).join("\n");
+  return `"use client"
+
+import { useForm } from "react-hook-form"
+import { zodResolver } from "@hookform/resolvers/zod"
+import { ${camel}Schema, type ${pascal}FormData } from "@/cmx/generated"
+import { useState } from "react"
 
-export * from "./data-types"
-export * from "./collections"
+type Props = {
+  action: (data: Record<string, unknown>) => Promise<{ success: true; id: string }>
+}
+
+export function ${pascal}Form({ action }: Props) {
+  const [status, setStatus] = useState<"idle" | "submitting" | "success" | "error">("idle")
+
+  const {
+    register,
+    handleSubmit,
+    reset,
+    formState: { errors },
+  } = useForm<${pascal}FormData>({
+    resolver: zodResolver(${camel}Schema),
+  })
+
+  const onSubmit = async (data: ${pascal}FormData) => {
+    setStatus("submitting")
+    try {
+      await action(data)
+      setStatus("success")
+      reset()
+    } catch {
+      setStatus("error")
+    }
+  }
+
+  if (status === "success") {
+    return <p>\u9001\u4FE1\u304C\u5B8C\u4E86\u3057\u307E\u3057\u305F\u3002\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002</p>
+  }
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      {/* Honeypot field */}
+      <div style={{ position: "absolute", left: "-9999px" }} aria-hidden="true">
+        <input type="text" name="_hp" tabIndex={-1} autoComplete="off" />
+      </div>
+
+${inputFields}
+
+      {status === "error" && (
+        <p role="alert">\u9001\u4FE1\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044\u3002</p>
+      )}
+
+      <button type="submit" disabled={status === "submitting"}>
+        {status === "submitting" ? "\u9001\u4FE1\u4E2D..." : "\u9001\u4FE1"}
+      </button>
+    </form>
+  )
+}
 `;
-    fs.writeFileSync(path.join(outputDir, "index.ts"), mainIndexContent, "utf-8");
-    console.log(`\u2713 Generated ${path.join(outputDir, "index.ts")}`);
-    console.log("\n\u2728 Generation complete!");
-    console.log(`Output directory: ${outputDir}`);
-  } catch (error) {
-    console.error("Error generating types:", error);
-    if (error instanceof Error) {
-      console.error(error.message);
+}
+function getInputType(fieldType) {
+  switch (fieldType) {
+    case "email":
+      return "email";
+    case "url":
+      return "url";
+    case "number":
+      return "number";
+    case "boolean":
+      return "checkbox";
+    case "textarea":
+    case "richtext":
+      return "text";
+    default:
+      return "text";
+  }
+}
+
+// src/codegen/scaffold-seo.ts
+function scaffoldSitemap(collections, siteUrl) {
+  const imports = collections.map((col) => {
+    const safeSlug = sanitizeIdentifier(col.slug);
+    const pascal = slugToPascalCase(safeSlug);
+    return `import { get${pascal}Contents } from "@/cmx/generated"`;
+  }).join("\n");
+  const fetchBlocks = collections.map((col) => {
+    const safeSlug = sanitizeIdentifier(col.slug);
+    const pascal = slugToPascalCase(safeSlug);
+    return `  const { contents: ${safeSlug.replace(/-/g, "")}Contents } = await get${pascal}Contents()
+  for (const item of ${safeSlug.replace(/-/g, "")}Contents) {
+    urls.push({
+      url: \`\${baseUrl}/${col.slug}/\${item.slug}\`,
+      lastModified: new Date(),
+    })
+  }`;
+  }).join("\n\n");
+  return `import type { MetadataRoute } from "next"
+${imports}
+
+const baseUrl = process.env.NEXT_PUBLIC_SITE_URL ?? "${siteUrl}"
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  const urls: MetadataRoute.Sitemap = [
+    { url: baseUrl, lastModified: new Date() },
+  ]
+
+${fetchBlocks}
+
+  return urls
+}
+`;
+}
+
+// src/codegen/scaffolder.ts
+async function writeScaffoldFile(filePath, content, result, options) {
+  const resolvedPath = resolve(filePath);
+  const resolvedAppDir = resolve(options.appDir);
+  if (!resolvedPath.startsWith(resolvedAppDir + "/") && resolvedPath !== resolvedAppDir) {
+    throw new Error(`Path traversal detected: "${filePath}" resolves outside of appDir "${options.appDir}"`);
+  }
+  if (!options.force && existsSync2(filePath)) {
+    result.skipped.push(filePath);
+    return;
+  }
+  if (options.dryRun) {
+    result.created.push(filePath);
+    return;
+  }
+  await mkdir2(dirname(filePath), { recursive: true });
+  await writeFile2(filePath, content, "utf-8");
+  result.created.push(filePath);
+}
+function parseOnly(only) {
+  const [category, slug] = only.split(":");
+  if (!category || !slug) return null;
+  return { category, slug };
+}
+async function scaffold(options) {
+  const { apiUrl, apiKey, appDir, dryRun, force, only } = options;
+  console.log(`Fetching schema from ${apiUrl} ...`);
+  const schema = await fetchSchema(apiUrl, apiKey);
+  const forms = schema.forms ?? [];
+  const filter = only ? parseOnly(only) : null;
+  if (only && !filter) {
+    console.error(`Invalid --only format: "${only}". Use category:slug (e.g. collections:blog)`);
+    process.exit(1);
+  }
+  const result = { created: [], skipped: [] };
+  const prefix = dryRun ? "[dry-run] " : "";
+  if (!filter || filter.category === "collections") {
+    const collections = filter ? schema.collections.filter((c) => c.slug === filter.slug) : schema.collections;
+    for (const col of collections) {
+      const safeSlug = sanitizeIdentifier(col.slug);
+      if (!safeSlug) continue;
+      const listPath = join3(appDir, safeSlug, "page.tsx");
+      await writeScaffoldFile(listPath, scaffoldCollectionListPage(col), result, { dryRun, force, appDir });
+      const detailPath = join3(appDir, safeSlug, "[slug]", "page.tsx");
+      await writeScaffoldFile(detailPath, scaffoldCollectionDetailPage(col), result, { dryRun, force, appDir });
+    }
+  }
+  if (!filter || filter.category === "data-types") {
+    const dataTypes = filter ? schema.dataTypes.filter((dt) => dt.slug === filter.slug) : schema.dataTypes;
+    for (const dt of dataTypes) {
+      const safeSlug = sanitizeIdentifier(dt.slug);
+      if (!safeSlug) continue;
+      const pagePath = join3(appDir, safeSlug, "page.tsx");
+      await writeScaffoldFile(pagePath, scaffoldDataTypePage(dt), result, { dryRun, force, appDir });
     }
+  }
+  if (!filter || filter.category === "forms") {
+    const filteredForms = filter ? forms.filter((f) => f.slug === filter.slug) : forms;
+    for (const form of filteredForms) {
+      const safeSlug = sanitizeIdentifier(form.slug);
+      if (!safeSlug) continue;
+      const pagePath = join3(appDir, safeSlug, "page.tsx");
+      await writeScaffoldFile(pagePath, scaffoldFormPage(form), result, { dryRun, force, appDir });
+      const componentPath = join3(appDir, safeSlug, "_components", `${safeSlug}-form.tsx`);
+      await writeScaffoldFile(componentPath, scaffoldFormComponent(form), result, { dryRun, force, appDir });
+    }
+  }
+  if (!filter) {
+    const sitemapPath = join3(appDir, "sitemap.ts");
+    if (schema.collections.length > 0) {
+      const siteUrl = apiUrl.replace(/\/api\/.*$/, "");
+      await writeScaffoldFile(sitemapPath, scaffoldSitemap(schema.collections, siteUrl), result, { dryRun, force, appDir });
+    }
+  }
+  console.log("");
+  if (result.created.length > 0) {
+    console.log(`${prefix}Created ${result.created.length} file(s):`);
+    for (const f of result.created) {
+      console.log(`  ${prefix}+ ${f}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log(`
+Skipped ${result.skipped.length} file(s) (already exist):`);
+    for (const f of result.skipped) {
+      console.log(`  - ${f}`);
+    }
+  }
+  if (result.created.length === 0 && result.skipped.length === 0) {
+    console.log("No files to scaffold.");
+  }
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Customize the generated pages' design (HTML/CSS)");
+  console.log("  2. Add navigation links to your layout");
+  console.log("  3. Run `npm run dev` to preview your site");
+}
+
+// src/commands/create-data-entry.ts
+async function createDataEntry(options) {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  if (!options.typeSlug) {
+    console.error("Error: --type-slug is required");
     process.exit(1);
   }
+  const input = readJsonInput(options);
+  if (!input.dataJson) {
+    console.error("Error: JSON must include dataJson");
+    process.exit(1);
+  }
+  console.log(`Creating data entry for type: ${options.typeSlug}...`);
+  const result = await manageApiFetch(apiUrl, apiKey, "POST", `/data/${options.typeSlug}`, input);
+  console.log("Data entry created successfully:");
+  console.log(JSON.stringify(result, null, 2));
 }
 
 // src/cli.ts
@@ -922,12 +1664,46 @@ program.command("list-components").description("List all custom components").act
 program.command("create-collection").description("Create a new collection").option("--json <json>", "JSON string with collection data").option("--type <type>", "Collection type (post, page, doc, news)").option("--slug <slug>", "Collection slug").option("--name <name>", "Collection name").option("--description <description>", "Collection description").action(createCollection);
 program.command("create-data-type").description("Create a new data type").option("--json <json>", "JSON string with data type data (recommended)").option("--slug <slug>", "Data type slug").option("--name <name>", "Data type name").option("--description <description>", "Data type description").action(createDataType);
 program.command("create-form").description("Create a new form definition").option("--json <json>", "JSON string with form data (recommended)").option("--slug <slug>", "Form slug").option("--name <name>", "Form name").option("--description <description>", "Form description").action(createForm);
-program.command("sync-components").description("Sync custom components").option("--file <file>", "Path to JSON file with components").option("--json <json>", "JSON string with components data").action(syncComponents);
-program.command("generate").description("Generate TypeScript types and functions from CMX schema").option("--output <dir>", "Output directory (default: cmx/generated)").action(generate);
+program.command("sync-components").description("Sync custom components").option("--file <file>", "Path to JSON file with components").option("--json <json>", "JSON string with components data").option("--environment <env>", "Deployment environment (auto-detected if omitted)").action(syncComponents);
+program.command("generate").description("Generate TypeScript types and functions from CMX schema").option("--output <dir>", "Output directory (default: cmx/generated)").action((options) => {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  return generate({
+    apiUrl,
+    apiKey,
+    outputDir: options.output || "cmx/generated"
+  });
+});
 program.command("update-collection").description("Update an existing collection").requiredOption("--slug <slug>", "Current slug of the collection").option("--json <json>", "JSON string with update data").option("--new-slug <slug>", "New slug").option("--name <name>", "New name").option("--description <description>", "New description").action(updateCollection);
 program.command("delete-collection").description("Delete a collection").requiredOption("--slug <slug>", "Collection slug").option("--force", "Skip confirmation prompt").option("--cascade", "Also delete associated content").action(deleteCollection);
 program.command("update-data-type").description("Update an existing data type").requiredOption("--slug <slug>", "Current slug of the data type").option("--json <json>", "JSON string with update data").option("--new-slug <slug>", "New slug").option("--name <name>", "New name").option("--description <description>", "New description").action(updateDataType);
 program.command("delete-data-type").description("Delete a data type").requiredOption("--slug <slug>", "Data type slug").option("--force", "Skip confirmation prompt").option("--cascade", "Also delete associated data entries").action(deleteDataType);
 program.command("update-form").description("Update an existing form definition").requiredOption("--slug <slug>", "Current slug of the form").option("--json <json>", "JSON string with update data").option("--new-slug <slug>", "New slug").option("--name <name>", "New name").option("--description <description>", "New description").action(updateForm);
 program.command("delete-form").description("Delete a form definition").requiredOption("--slug <slug>", "Form slug").option("--force", "Skip confirmation prompt").action(deleteForm);
+program.command("list-collection-data-types").description("List data types attached to a collection").requiredOption("--collection <slug>", "Collection slug").action(listCollectionDataTypes);
+program.command("add-collection-data-type").description("Add a data type to a collection (from preset or custom)").requiredOption("--collection <slug>", "Collection slug").option("--preset <slug>", "Preset slug (e.g. categories, tags, authors)").option("--json <json>", "JSON string with custom data type definition").option("--file <file>", "Path to JSON file with custom data type definition").action(addCollectionDataType);
+program.command("remove-collection-data-type").description("Remove a data type from a collection").requiredOption("--collection <slug>", "Collection slug").requiredOption("--data-type <slug>", "Data type slug to remove").action(removeCollectionDataType);
+program.command("link-collection-data-type").description("Link an existing global data type to a collection").requiredOption("--collection <slug>", "Collection slug").requiredOption("--data-type <slug>", "Global data type slug to link").requiredOption("--field-slug <slug>", "Reference field slug").requiredOption("--label <label>", "Reference field display label").option("--reference-type <type>", "Reference type: single or multiple (default: single)", "single").action(linkCollectionDataType);
+program.command("list-collection-presets").description("List available presets for collection data types").option("--type <type>", "Collection type (post, news, doc, page)").action(listCollectionPresets);
+program.command("scaffold").description("Generate Next.js pages from CMX schema").option("--app-dir <dir>", "App directory path (default: app/(public))").option("--dry-run", "Preview without writing files").option("--force", "Overwrite existing files").option("--only <filter>", "Scaffold only specific items (e.g. collections:blog)").action((options) => {
+  const apiUrl = process.env.CMX_API_URL;
+  const apiKey = process.env.CMX_API_KEY;
+  if (!apiUrl || !apiKey) {
+    console.error("Error: CMX_API_URL and CMX_API_KEY environment variables are required");
+    process.exit(1);
+  }
+  return scaffold({
+    apiUrl,
+    apiKey,
+    appDir: options.appDir || "app/(public)",
+    dryRun: options.dryRun,
+    force: options.force,
+    only: options.only
+  });
+});
+program.command("create-data-entry").description("Create a new data entry").requiredOption("--type-slug <slug>", "Data type slug").option("--json <json>", "JSON string with entry data").option("--file <file>", "Path to JSON file with entry data").action(createDataEntry);
 program.parse();