cmx-sdk 0.2.1 → 0.2.3

package/dist/cli.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  studio
+} from "./chunk-XPP5MZKG.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -381,10 +384,10 @@ async function confirm(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve5(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -426,10 +429,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve5(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -471,10 +474,10 @@ async function confirm3(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     rl.question(`${message} (y/N): `, (answer) => {
       rl.close();
-      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve5(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -513,78 +516,199 @@ async function deleteForm(options) {
 // src/commands/sync-components.ts
 import { readdirSync, readFileSync as readFileSync2, existsSync } from "fs";
 import { join } from "path";
-import { execSync } from "child_process";
-function detectEnvironment() {
-  try {
-    const branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
-    if (branch === "main") return "production";
-    if (branch === "develop") return "staging";
-    const prMatch = branch.match(/^(?:feature|fix)\/(.+)$/);
-    if (prMatch) {
-      try {
-        const prNumber = execSync("gh pr view --json number -q .number", {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "ignore"]
-        }).trim();
-        if (prNumber) return `preview/pr-${prNumber}`;
-      } catch {
-      }
-    }
-    return `preview/${branch.replace(/[^a-zA-Z0-9-]/g, "-")}`;
-  } catch {
-    return "production";
-  }
+import { z as z2 } from "zod";
+
+// src/mdx/component-catalog.ts
+import { z } from "zod";
+var componentSchemas = {
+  BlogCard: z.object({
+    contentId: z.string().uuid().describe("\u53C2\u7167\u5148\u30B3\u30F3\u30C6\u30F3\u30C4\u306EUUID")
+  }),
+  Image: z.object({
+    assetId: z.string().uuid().describe("\u30A2\u30BB\u30C3\u30C8\u306EUUID"),
+    alt: z.string().optional().describe("\u4EE3\u66FF\u30C6\u30AD\u30B9\u30C8"),
+    size: z.enum(["thumbnail", "medium", "large", "original"]).default("large").describe("\u8868\u793A\u30B5\u30A4\u30BA"),
+    caption: z.string().optional().describe("\u30AD\u30E3\u30D7\u30B7\u30E7\u30F3")
+  }),
+  Callout: z.object({
+    type: z.enum(["info", "warning", "error", "success", "tip"]).default("info").describe("\u30BF\u30A4\u30D7"),
+    title: z.string().optional().describe("\u30BF\u30A4\u30C8\u30EB"),
+    children: z.string().describe("\u672C\u6587\uFF08Markdown\u53EF\uFF09")
+  }),
+  Embed: z.object({
+    url: z.string().url().describe("\u57CB\u3081\u8FBC\u307FURL"),
+    type: z.enum(["youtube", "twitter", "generic"]).default("generic").describe("\u30BF\u30A4\u30D7")
+  }),
+  Button: z.object({
+    href: z.string().describe("\u30EA\u30F3\u30AF\u5148URL"),
+    children: z.string().describe("\u30DC\u30BF\u30F3\u30C6\u30AD\u30B9\u30C8"),
+    variant: z.enum(["primary", "secondary", "outline"]).default("primary").describe("\u30B9\u30BF\u30A4\u30EB")
+  })
+};
+var componentCatalog = {
+  BlogCard: {
+    name: "BlogCard",
+    displayName: "\u8A18\u4E8B\u30AB\u30FC\u30C9",
+    description: "\u4ED6\u306E\u8A18\u4E8B\u3078\u306E\u30EA\u30F3\u30AF\u30AB\u30FC\u30C9\u3092\u8868\u793A\u3057\u307E\u3059",
+    category: "reference",
+    schema: componentSchemas.BlogCard,
+    examples: ['<BlogCard contentId="123e4567-e89b-12d3-a456-426614174000" />'],
+    hasReferences: true,
+    source: "standard",
+    kind: "data-bound",
+    locked: true,
+    editable: false,
+    bindings: [{ prop: "contentId", target: "content", strategy: "by-id" }]
+  },
+  Image: {
+    name: "Image",
+    displayName: "\u753B\u50CF",
+    description: "\u30A2\u30C3\u30D7\u30ED\u30FC\u30C9\u6E08\u307F\u753B\u50CF\u3092\u8868\u793A\u3057\u307E\u3059",
+    category: "media",
+    schema: componentSchemas.Image,
+    examples: [
+      '<Image assetId="123e4567-e89b-12d3-a456-426614174000" alt="\u8AAC\u660E" />',
+      '<Image assetId="123e4567-e89b-12d3-a456-426614174000" size="medium" caption="\u30AD\u30E3\u30D7\u30B7\u30E7\u30F3" />'
+    ],
+    hasReferences: true,
+    source: "standard",
+    kind: "data-bound",
+    locked: true,
+    editable: false,
+    bindings: [{ prop: "assetId", target: "asset", strategy: "by-id" }]
+  },
+  Callout: {
+    name: "Callout",
+    displayName: "\u30B3\u30FC\u30EB\u30A2\u30A6\u30C8",
+    description: "\u6CE8\u610F\u66F8\u304D\u3084\u88DC\u8DB3\u60C5\u5831\u3092\u76EE\u7ACB\u305F\u305B\u308B\u30DC\u30C3\u30AF\u30B9",
+    category: "content",
+    schema: componentSchemas.Callout,
+    examples: [
+      '<Callout type="info">\u3053\u308C\u306F\u60C5\u5831\u3067\u3059</Callout>',
+      '<Callout type="warning" title="\u6CE8\u610F">\u91CD\u8981\u306A\u6CE8\u610F\u4E8B\u9805\u3067\u3059</Callout>'
+    ],
+    hasReferences: false,
+    source: "standard",
+    kind: "presentational",
+    locked: true,
+    editable: false
+  },
+  Embed: {
+    name: "Embed",
+    displayName: "\u57CB\u3081\u8FBC\u307F",
+    description: "YouTube\u52D5\u753B\u3084\u30C4\u30A4\u30FC\u30C8\u3092\u57CB\u3081\u8FBC\u307F\u307E\u3059",
+    category: "media",
+    schema: componentSchemas.Embed,
+    examples: [
+      '<Embed url="https://www.youtube.com/watch?v=dQw4w9WgXcQ" type="youtube" />',
+      '<Embed url="https://twitter.com/example/status/123456789" type="twitter" />'
+    ],
+    hasReferences: false,
+    source: "standard",
+    kind: "presentational",
+    locked: true,
+    editable: false
+  },
+  Button: {
+    name: "Button",
+    displayName: "\u30DC\u30BF\u30F3",
+    description: "\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u4FC3\u3059\u30DC\u30BF\u30F3\u30EA\u30F3\u30AF",
+    category: "content",
+    schema: componentSchemas.Button,
+    examples: [
+      '<Button href="/contact">\u304A\u554F\u3044\u5408\u308F\u305B</Button>',
+      '<Button href="https://example.com" variant="secondary">\u8A73\u7D30\u3092\u898B\u308B</Button>'
+    ],
+    hasReferences: false,
+    source: "standard",
+    kind: "presentational",
+    locked: true,
+    editable: false
+  }
+};
+function isValidComponent(name) {
+  return name in componentCatalog;
+}
+function validateComponentProps(name, props) {
+  const schema = componentSchemas[name];
+  const result = schema.safeParse(props);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+function isStandardComponentName(name) {
+  return isValidComponent(name);
 }
-function readComponentDefinitions(componentsDir, environment) {
+
+// src/commands/sync-components.ts
+var ComponentPropSchema = z2.object({
+  type: z2.enum(["string", "number", "boolean", "enum", "asset", "content"]),
+  description: z2.string().optional(),
+  required: z2.boolean().optional().default(false),
+  values: z2.array(z2.string()).optional(),
+  default: z2.union([z2.string(), z2.number(), z2.boolean()]).optional()
+});
+var ComponentDefinitionSchema = z2.object({
+  name: z2.string().min(1).max(100).regex(/^[A-Z][a-zA-Z0-9]*$/),
+  displayName: z2.string().min(1).max(255),
+  description: z2.string().optional(),
+  propsSchema: z2.record(ComponentPropSchema).default({}),
+  examples: z2.array(z2.string()).default([])
+});
+function readComponentDefinitions(componentsDir) {
   if (!existsSync(componentsDir)) {
     console.log("No components directory found at cmx/components/");
-    return [];
+    return { exists: false, components: [] };
   }
   const files = readdirSync(componentsDir).filter((f) => f.endsWith(".json"));
-  if (files.length === 0) {
-    console.log("No component definition files found");
-    return [];
-  }
   const components = [];
   for (const file of files) {
     try {
       const filePath = join(componentsDir, file);
       const content = readFileSync2(filePath, "utf-8");
-      const component = JSON.parse(content);
-      if (!component.environment) {
-        component.environment = environment;
+      const parsed = JSON.parse(content);
+      const result = ComponentDefinitionSchema.safeParse(parsed);
+      if (!result.success) {
+        console.error(`  Invalid format in ${file}`);
+        for (const issue of result.error.issues) {
+          const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+          console.error(`    - ${path}: ${issue.message}`);
+        }
+        process.exit(1);
       }
-      if (!component.name || !component.displayName) {
-        console.warn(`  Skipping ${file}: missing required fields (name, displayName)`);
-        continue;
+      if (isValidComponent(result.data.name)) {
+        console.error(`  ${file}: '${result.data.name}' \u306F\u6A19\u6E96\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\u540D\u306E\u305F\u3081\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
+        process.exit(1);
       }
-      component.propsSchema = component.propsSchema || {};
-      component.examples = component.examples || [];
-      components.push(component);
+      components.push(result.data);
     } catch (error) {
       console.error(`  Error reading ${file}:`, error instanceof Error ? error.message : error);
+      process.exit(1);
     }
   }
-  return components;
+  return { exists: true, components };
 }
-async function syncComponents(options) {
+async function syncComponents() {
   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);
-  if (components.length === 0) {
+  const { exists, components } = readComponentDefinitions(componentsDir);
+  if (!exists) {
     console.log("No components to sync");
     return;
   }
-  console.log(`Found ${components.length} components:`);
-  for (const c of components) {
-    console.log(`  - ${c.name} (${c.displayName})`);
+  if (components.length === 0) {
+    console.log("No component definition files found, syncing empty list (will delete existing custom components)");
+  } else {
+    console.log(`Found ${components.length} components:`);
+    for (const c of components) {
+      console.log(`  - ${c.name} (${c.displayName})`);
+    }
   }
   console.log(`Syncing to ${apiUrl}...`);
   const result = await manageApiFetch(
@@ -597,6 +721,7 @@ async function syncComponents(options) {
   console.log(`Success: ${result.message || "Components synced"}`);
   if (result.created) console.log(`  Created: ${result.created}`);
   if (result.updated) console.log(`  Updated: ${result.updated}`);
+  if (result.deleted) console.log(`  Deleted: ${result.deleted}`);
 }
 
 // src/codegen/generator.ts
@@ -719,7 +844,7 @@ function generateDataTypeFile(dataType) {
   const interfaceName = singularize(pascalPlural);
   const slug = dataType.slug;
   const lines = [];
-  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Auto-generated by cmx-sdk codegen types`);
   lines.push(`// Data Type: ${dataType.name} (${slug})`);
   lines.push(`// Do not edit manually.`);
   lines.push(``);
@@ -774,7 +899,7 @@ function generateCollectionFile(collection) {
   const slug = collection.slug;
   const lines = [];
   const escapedName = escapeTs(collection.name);
-  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Auto-generated by cmx-sdk codegen types`);
   lines.push(`// Collection: ${escapedName} (${slug})`);
   lines.push(`// Do not edit manually.`);
   lines.push(``);
@@ -860,7 +985,7 @@ function generateFormFile(form) {
   const slug = form.slug;
   const lines = [];
   const escapedName = escapeTs(form.name);
-  lines.push(`// Auto-generated by cmx-sdk generate`);
+  lines.push(`// Auto-generated by cmx-sdk codegen types`);
   lines.push(`// Form: ${escapedName} (${slug})`);
   lines.push(`// Do not edit manually.`);
   lines.push(``);
@@ -892,7 +1017,7 @@ function generateFormFile(form) {
 // src/codegen/generate-index.ts
 function generateDataTypesIndex(slugs) {
   const lines = [
-    `// Auto-generated by cmx-sdk generate`,
+    `// Auto-generated by cmx-sdk codegen types`,
     `// Do not edit manually.`,
     ``
   ];
@@ -904,7 +1029,7 @@ function generateDataTypesIndex(slugs) {
 }
 function generateCollectionsIndex(slugs) {
   const lines = [
-    `// Auto-generated by cmx-sdk generate`,
+    `// Auto-generated by cmx-sdk codegen types`,
     `// Do not edit manually.`,
     ``
   ];
@@ -916,7 +1041,7 @@ function generateCollectionsIndex(slugs) {
 }
 function generateFormsIndex(slugs) {
   const lines = [
-    `// Auto-generated by cmx-sdk generate`,
+    `// Auto-generated by cmx-sdk codegen types`,
     `// Do not edit manually.`,
     ``
   ];
@@ -928,7 +1053,7 @@ function generateFormsIndex(slugs) {
 }
 function generateRootIndex(hasDataTypes, hasCollections, hasForms) {
   const lines = [
-    `// Auto-generated by cmx-sdk generate`,
+    `// Auto-generated by cmx-sdk codegen types`,
     `// Do not edit manually.`,
     ``
   ];
@@ -1253,7 +1378,7 @@ async function linkCollectionDataType(opts) {
 // 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";
+import { dirname, join as join3, resolve } from "path";
 
 // src/codegen/scaffold-collection.ts
 function scaffoldCollectionListPage(collection) {
@@ -1261,7 +1386,7 @@ function scaffoldCollectionListPage(collection) {
   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"
+  return `import { get${pascal}Contents } from "@cmx/generated"
 import Link from "next/link"
 import type { Metadata } from "next"
 
@@ -1294,7 +1419,7 @@ export default async function ${pascal}Page() {
 function scaffoldCollectionDetailPage(collection) {
   const safeSlug = sanitizeIdentifier(collection.slug);
   const pascal = slugToPascalCase(safeSlug);
-  return `import { get${pascal}Contents, get${pascal}ContentDetail } from "@/cmx/generated"
+  return `import { get${pascal}Contents, get${pascal}ContentDetail } from "@cmx/generated"
 import { renderMdx } from "cmx-sdk"
 import type { Metadata } from "next"
 
@@ -1340,8 +1465,8 @@ function scaffoldDataTypePage(dataType) {
   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"
+  return `import { get${pascalPlural} } from "@cmx/generated"
+import type { ${interfaceName} } from "@cmx/generated"
 import type { Metadata } from "next"
 
 export const metadata: Metadata = {
@@ -1377,7 +1502,7 @@ function scaffoldFormPage(form) {
   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 { ${camel}Schema, submit${pascal} } from "@cmx/generated"
 import type { Metadata } from "next"
 
 export const metadata: Metadata = {
@@ -1424,7 +1549,7 @@ function scaffoldFormComponent(form) {
 
 import { useForm } from "react-hook-form"
 import { zodResolver } from "@hookform/resolvers/zod"
-import { ${camel}Schema, type ${pascal}FormData } from "@/cmx/generated"
+import { ${camel}Schema, type ${pascal}FormData } from "@cmx/generated"
 import { useState } from "react"
 
 type Props = {
@@ -1497,12 +1622,393 @@ function getInputType(fieldType) {
   }
 }
 
+// src/codegen/scaffold-layered.ts
+function scaffoldLayeredCollectionListRoute(collection, featureImportBase = "@/features") {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import { ${pascal}ListView } from "${featureImportBase}/collections/${safeSlug}/list/view"
+import { get${pascal}ListData } from "${featureImportBase}/collections/${safeSlug}/list/resolver"
+export { metadata } from "${featureImportBase}/collections/${safeSlug}/list/meta"
+
+export default async function ${pascal}Page() {
+  const data = await get${pascal}ListData()
+  return <${pascal}ListView data={data} />
+}
+`;
+}
+function scaffoldLayeredCollectionListResolver(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import { get${pascal}Contents } from "@cmx/generated"
+
+export async function get${pascal}ListData() {
+  return get${pascal}Contents()
+}
+
+export type ${pascal}ListData = Awaited<ReturnType<typeof get${pascal}ListData>>
+`;
+}
+function scaffoldLayeredCollectionListMeta(collection) {
+  const escapedName = escapeTs(collection.name);
+  const escapedDescription = escapeTs(collection.description ?? `${collection.name}\u306E\u4E00\u89A7`);
+  return `import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapedName}",
+  description: "${escapedDescription}",
+}
+`;
+}
+function scaffoldLayeredCollectionListView(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const escapedName = escapeTs(collection.name);
+  return `import Link from "next/link"
+import type { ${pascal}ListData } from "./resolver"
+
+type Props = {
+  data: ${pascal}ListData
+}
+
+export function ${pascal}ListView({ data }: Props) {
+  const { contents } = data
+
+  return (
+    <main>
+      <h1>${escapedName}</h1>
+      {contents.length === 0 ? (
+        <p>No content yet.</p>
+      ) : (
+        <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 scaffoldLayeredCollectionDetailRoute(collection, featureImportBase = "@/features") {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import type { Metadata } from "next"
+import {
+  get${pascal}DetailData,
+  get${pascal}DetailParams,
+} from "${featureImportBase}/collections/${safeSlug}/detail/resolver"
+import { get${pascal}DetailMetadata } from "${featureImportBase}/collections/${safeSlug}/detail/meta"
+import { ${pascal}DetailView } from "${featureImportBase}/collections/${safeSlug}/detail/view"
+
+type Props = {
+  params: Promise<{ slug: string }>
+}
+
+export async function generateStaticParams() {
+  return get${pascal}DetailParams()
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { slug } = await params
+  return get${pascal}DetailMetadata(slug)
+}
+
+export default async function ${pascal}DetailPage({ params }: Props) {
+  const { slug } = await params
+  const data = await get${pascal}DetailData(slug)
+
+  return <${pascal}DetailView data={data} />
+}
+`;
+}
+function scaffoldLayeredCollectionDetailResolver(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"
+
+export async function get${pascal}DetailParams() {
+  const { contents } = await get${pascal}Contents()
+  return contents.map((item) => ({ slug: item.slug }))
+}
+
+export async function get${pascal}DetailData(slug: string) {
+  const { content, references } = await get${pascal}ContentDetail(slug)
+  const { content: rendered } = await renderMdx(content.mdx, references)
+
+  return {
+    content,
+    rendered,
+  }
+}
+
+export type ${pascal}DetailData = Awaited<ReturnType<typeof get${pascal}DetailData>>
+`;
+}
+function scaffoldLayeredCollectionDetailMeta(collection) {
+  const safeSlug = sanitizeIdentifier(collection.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import type { Metadata } from "next"
+import { get${pascal}ContentDetail } from "@cmx/generated"
+
+export async function get${pascal}DetailMetadata(slug: string): Promise<Metadata> {
+  const { content } = await get${pascal}ContentDetail(slug)
+
+  return {
+    title: content.title,
+    description: content.description ?? undefined,
+  }
+}
+`;
+}
+function scaffoldLayeredCollectionDetailView(collection) {
+  const pascal = slugToPascalCase(sanitizeIdentifier(collection.slug));
+  return `import type { ${pascal}DetailData } from "./resolver"
+
+type Props = {
+  data: ${pascal}DetailData
+}
+
+export function ${pascal}DetailView({ data }: Props) {
+  const { content, rendered } = data
+
+  return (
+    <main>
+      <article>
+        <h1>{content.title}</h1>
+        {rendered}
+      </article>
+    </main>
+  )
+}
+`;
+}
+function scaffoldLayeredDataTypeRoute(dataType, featureImportBase = "@/features") {
+  const safeSlug = sanitizeIdentifier(dataType.slug);
+  const pascalPlural = slugToPascalCase(safeSlug);
+  return `import { ${pascalPlural}ListView } from "${featureImportBase}/data-types/${safeSlug}/list/view"
+import { get${pascalPlural}ListData } from "${featureImportBase}/data-types/${safeSlug}/list/resolver"
+export { metadata } from "${featureImportBase}/data-types/${safeSlug}/list/meta"
+
+export default async function ${pascalPlural}Page() {
+  const data = await get${pascalPlural}ListData()
+  return <${pascalPlural}ListView data={data} />
+}
+`;
+}
+function scaffoldLayeredDataTypeResolver(dataType) {
+  const safeSlug = sanitizeIdentifier(dataType.slug);
+  const pascalPlural = slugToPascalCase(safeSlug);
+  return `import { get${pascalPlural} } from "@cmx/generated"
+
+export async function get${pascalPlural}ListData() {
+  return get${pascalPlural}()
+}
+
+export type ${pascalPlural}ListData = Awaited<ReturnType<typeof get${pascalPlural}ListData>>
+`;
+}
+function scaffoldLayeredDataTypeMeta(dataType) {
+  return `import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapeTs(dataType.name)}",
+}
+`;
+}
+function scaffoldLayeredDataTypeView(dataType) {
+  const safeSlug = sanitizeIdentifier(dataType.slug);
+  const pascalPlural = slugToPascalCase(safeSlug);
+  const interfaceName = singularize(pascalPlural);
+  const fieldComments = dataType.fields.map((f) => `//   ${f.key}: ${f.type}${f.required ? "" : " (optional)"}`).join("\n");
+  return `import type { ${pascalPlural}ListData } from "./resolver"
+import type { ${interfaceName} } from "@cmx/generated"
+
+type Props = {
+  data: ${pascalPlural}ListData
+}
+
+// Available fields:
+${fieldComments}
+
+export function ${pascalPlural}ListView({ data }: Props) {
+  const { items } = data
+
+  return (
+    <main>
+      <h1>${escapeTs(dataType.name)}</h1>
+      <ul>
+        {items.map((item: ${interfaceName}, index: number) => (
+          <li key={index}>
+            <pre>{JSON.stringify(item, null, 2)}</pre>
+          </li>
+        ))}
+      </ul>
+    </main>
+  )
+}
+`;
+}
+function scaffoldLayeredFormRoute(form, featureImportBase = "@/features") {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import { ${pascal}PageView } from "${featureImportBase}/forms/${safeSlug}/view"
+import { submit${pascal}FormAction } from "${featureImportBase}/forms/${safeSlug}/resolver"
+export { metadata } from "${featureImportBase}/forms/${safeSlug}/meta"
+
+export default function ${pascal}Page() {
+  return <${pascal}PageView action={submit${pascal}FormAction} />
+}
+`;
+}
+function scaffoldLayeredFormResolver(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const camel = slugToCamelCase(safeSlug);
+  return `import { ${camel}Schema, submit${pascal}, type ${pascal}FormData } from "@cmx/generated"
+
+export async function submit${pascal}FormAction(data: Record<string, unknown>) {
+  "use server"
+  const validated = ${camel}Schema.parse(data)
+  return submit${pascal}(validated as ${pascal}FormData)
+}
+`;
+}
+function scaffoldLayeredFormMeta(form) {
+  return `import type { Metadata } from "next"
+
+export const metadata: Metadata = {
+  title: "${escapeTs(form.name)}",
+}
+`;
+}
+function scaffoldLayeredFormView(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  return `import { ${pascal}FormView } from "./form-view"
+
+type Props = {
+  action: (data: Record<string, unknown>) => Promise<{ success: true; id: string }>
+}
+
+export function ${pascal}PageView({ action }: Props) {
+  return (
+    <main>
+      <h1>${escapeTs(form.name)}</h1>
+      <${pascal}FormView action={action} />
+    </main>
+  )
+}
+`;
+}
+function scaffoldLayeredFormClientView(form) {
+  const safeSlug = sanitizeIdentifier(form.slug);
+  const pascal = slugToPascalCase(safeSlug);
+  const camel = slugToCamelCase(safeSlug);
+  const inputFields = form.fields.map((field) => {
+    const inputType = getInputType2(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 { useState } from "react"
+import { useForm } from "react-hook-form"
+import { zodResolver } from "@hookform/resolvers/zod"
+import { ${camel}Schema, type ${pascal}FormData } from "@cmx/generated"
+
+type Props = {
+  action: (data: Record<string, unknown>) => Promise<{ success: true; id: string }>
+}
+
+export function ${pascal}FormView({ 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)}>
+      <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>
+  )
+}
+`;
+}
+function getInputType2(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"`;
+    return `import { get${pascal}Contents } from "@cmx/generated"`;
   }).join("\n");
   const fetchBlocks = collections.map((col) => {
     const safeSlug = sanitizeIdentifier(col.slug);
@@ -1535,9 +2041,11 @@ ${fetchBlocks}
 // 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}"`);
+  const resolvedBaseDir = resolve(options.baseDir);
+  if (!resolvedPath.startsWith(resolvedBaseDir + "/") && resolvedPath !== resolvedBaseDir) {
+    throw new Error(
+      `Path traversal detected: "${filePath}" resolves outside of base dir "${options.baseDir}"`
+    );
   }
   if (!options.force && existsSync2(filePath)) {
     result.skipped.push(filePath);
@@ -1552,12 +2060,49 @@ async function writeScaffoldFile(filePath, content, result, options) {
   result.created.push(filePath);
 }
 function parseOnly(only) {
-  const [category, slug] = only.split(":");
-  if (!category || !slug) return null;
-  return { category, slug };
+  const [categoryRaw, slug] = only.split(":");
+  if (!categoryRaw || !slug) return null;
+  if (categoryRaw !== "collections" && categoryRaw !== "data-types" && categoryRaw !== "forms") {
+    return null;
+  }
+  return { category: categoryRaw, slug };
+}
+function parseTemplate(template) {
+  if (!template || template === "layered") {
+    return "layered";
+  }
+  if (template === "legacy") {
+    return "legacy";
+  }
+  throw new Error(`Invalid template: "${template}". Use "legacy" or "layered".`);
+}
+function inferFeaturesDir(appDir) {
+  const normalized = appDir.replace(/\\/g, "/");
+  if (normalized.startsWith("src/")) {
+    return "src/features";
+  }
+  if (normalized.includes("/src/")) {
+    return "src/features";
+  }
+  return "features";
+}
+function inferFeatureImportBase(featuresDir) {
+  const normalized = featuresDir.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (normalized === "src/features") {
+    return "@/features";
+  }
+  if (normalized.startsWith("src/")) {
+    return `@/${normalized.slice("src/".length)}`;
+  }
+  throw new Error(
+    `Layered template requires --features-dir to be under src/ (received: "${featuresDir}")`
+  );
 }
 async function scaffold(options) {
   const { apiUrl, apiKey, appDir, dryRun, force, only } = options;
+  const template = parseTemplate(options.template);
+  const featuresDir = template === "layered" ? options.featuresDir ?? inferFeaturesDir(appDir) : null;
+  const featureImportBase = template === "layered" ? inferFeatureImportBase(featuresDir ?? inferFeaturesDir(appDir)) : null;
   console.log(`Fetching schema from ${apiUrl} ...`);
   const schema = await fetchSchema(apiUrl, apiKey);
   const forms = schema.forms ?? [];
@@ -1573,10 +2118,77 @@ async function scaffold(options) {
     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 (template === "legacy") {
+        const listPath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(listPath, scaffoldCollectionListPage(col), result, { dryRun, force, baseDir: appDir });
+        const detailPath = join3(appDir, safeSlug, "[slug]", "page.tsx");
+        await writeScaffoldFile(detailPath, scaffoldCollectionDetailPage(col), result, { dryRun, force, baseDir: appDir });
+      } else {
+        const listRoutePath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(
+          listRoutePath,
+          scaffoldLayeredCollectionListRoute(col, featureImportBase ?? "@/features"),
+          result,
+          {
+            dryRun,
+            force,
+            baseDir: appDir
+          }
+        );
+        const detailRoutePath = join3(appDir, safeSlug, "[slug]", "page.tsx");
+        await writeScaffoldFile(
+          detailRoutePath,
+          scaffoldLayeredCollectionDetailRoute(col, featureImportBase ?? "@/features"),
+          result,
+          {
+            dryRun,
+            force,
+            baseDir: appDir
+          }
+        );
+        const listFeatureBase = join3(featuresDir, "collections", safeSlug, "list");
+        await writeScaffoldFile(
+          join3(listFeatureBase, "resolver.ts"),
+          scaffoldLayeredCollectionListResolver(col),
+          result,
+          {
+            dryRun,
+            force,
+            baseDir: featuresDir
+          }
+        );
+        await writeScaffoldFile(join3(listFeatureBase, "meta.ts"), scaffoldLayeredCollectionListMeta(col), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(listFeatureBase, "view.tsx"), scaffoldLayeredCollectionListView(col), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        const detailFeatureBase = join3(featuresDir, "collections", safeSlug, "detail");
+        await writeScaffoldFile(
+          join3(detailFeatureBase, "resolver.ts"),
+          scaffoldLayeredCollectionDetailResolver(col),
+          result,
+          {
+            dryRun,
+            force,
+            baseDir: featuresDir
+          }
+        );
+        await writeScaffoldFile(join3(detailFeatureBase, "meta.ts"), scaffoldLayeredCollectionDetailMeta(col), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(detailFeatureBase, "view.tsx"), scaffoldLayeredCollectionDetailView(col), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+      }
     }
   }
   if (!filter || filter.category === "data-types") {
@@ -1584,8 +2196,38 @@ async function scaffold(options) {
     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 (template === "legacy") {
+        const pagePath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(pagePath, scaffoldDataTypePage(dt), result, { dryRun, force, baseDir: appDir });
+      } else {
+        const pagePath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(
+          pagePath,
+          scaffoldLayeredDataTypeRoute(dt, featureImportBase ?? "@/features"),
+          result,
+          {
+            dryRun,
+            force,
+            baseDir: appDir
+          }
+        );
+        const featureBase = join3(featuresDir, "data-types", safeSlug, "list");
+        await writeScaffoldFile(join3(featureBase, "resolver.ts"), scaffoldLayeredDataTypeResolver(dt), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(featureBase, "meta.ts"), scaffoldLayeredDataTypeMeta(dt), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(featureBase, "view.tsx"), scaffoldLayeredDataTypeView(dt), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+      }
     }
   }
   if (!filter || filter.category === "forms") {
@@ -1593,17 +2235,56 @@ async function scaffold(options) {
     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 (template === "legacy") {
+        const pagePath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(pagePath, scaffoldFormPage(form), result, { dryRun, force, baseDir: appDir });
+        const componentPath = join3(appDir, safeSlug, "_components", `${safeSlug}-form.tsx`);
+        await writeScaffoldFile(componentPath, scaffoldFormComponent(form), result, {
+          dryRun,
+          force,
+          baseDir: appDir
+        });
+      } else {
+        const pagePath = join3(appDir, safeSlug, "page.tsx");
+        await writeScaffoldFile(
+          pagePath,
+          scaffoldLayeredFormRoute(form, featureImportBase ?? "@/features"),
+          result,
+          { dryRun, force, baseDir: appDir }
+        );
+        const featureBase = join3(featuresDir, "forms", safeSlug);
+        await writeScaffoldFile(join3(featureBase, "resolver.ts"), scaffoldLayeredFormResolver(form), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(featureBase, "meta.ts"), scaffoldLayeredFormMeta(form), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(featureBase, "view.tsx"), scaffoldLayeredFormView(form), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+        await writeScaffoldFile(join3(featureBase, "form-view.tsx"), scaffoldLayeredFormClientView(form), result, {
+          dryRun,
+          force,
+          baseDir: featuresDir
+        });
+      }
     }
   }
   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 });
+      await writeScaffoldFile(sitemapPath, scaffoldSitemap(schema.collections, siteUrl), result, {
+        dryRun,
+        force,
+        baseDir: appDir
+      });
     }
   }
   console.log("");
@@ -1625,8 +2306,13 @@ Skipped ${result.skipped.length} file(s) (already exist):`);
   }
   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");
+  if (template === "layered") {
+    console.log("  1. Customize view files under the generated features directory");
+    console.log(`  2. Keep data fetching in resolver files (${featuresDir})`);
+  } else {
+    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");
 }
 
@@ -1907,10 +2593,10 @@ async function deleteDataEntry(options) {
       input: process.stdin,
       output: process.stdout
     });
-    const answer = await new Promise((resolve2) => {
+    const answer = await new Promise((resolve5) => {
       rl.question(
         `Are you sure you want to delete data entry ${options.id}? (yes/no): `,
-        resolve2
+        resolve5
       );
     });
     rl.close();
@@ -1930,22 +2616,695 @@ async function deleteDataEntry(options) {
   console.log(JSON.stringify(result, null, 2));
 }
 
+// src/commands/scaffold-component.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join4 } from "path";
+function toPascalCase(input) {
+  const cleaned = input.replace(/[^a-zA-Z0-9_-]/g, "-");
+  return cleaned.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function toKebabCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]/g, "-").toLowerCase();
+}
+function ensureDir(path) {
+  if (!existsSync3(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function ensureExport(indexPath, exportName) {
+  const exportLine = `export { ${exportName} } from "./${exportName}"
+`;
+  if (!existsSync3(indexPath)) {
+    writeFileSync(indexPath, exportLine, "utf-8");
+    return;
+  }
+  const current = readFileSync3(indexPath, "utf-8");
+  if (current.includes(exportLine.trim())) {
+    return;
+  }
+  const needsNewline = current.length > 0 && !current.endsWith("\n");
+  writeFileSync(indexPath, `${current}${needsNewline ? "\n" : ""}${exportLine}`, "utf-8");
+}
+async function scaffoldComponent(options) {
+  const pascalName = toPascalCase(options.name);
+  if (!/^[A-Z][a-zA-Z0-9]*$/.test(pascalName)) {
+    console.error("Error: name must resolve to PascalCase (e.g. FeatureCard)");
+    process.exit(1);
+  }
+  const kebabName = toKebabCase(pascalName);
+  const componentsDir = options.componentsDir || join4(process.cwd(), "src/components/custom");
+  const definitionsDir = options.definitionsDir || join4(process.cwd(), "cmx/components");
+  ensureDir(componentsDir);
+  ensureDir(definitionsDir);
+  const componentPath = join4(componentsDir, `${pascalName}.tsx`);
+  const definitionPath = join4(definitionsDir, `${kebabName}.json`);
+  const indexPath = join4(componentsDir, "index.ts");
+  if (!options.force && (existsSync3(componentPath) || existsSync3(definitionPath))) {
+    console.error("Error: target files already exist. Use --force to overwrite");
+    process.exit(1);
+  }
+  const definition = {
+    name: pascalName,
+    displayName: pascalName,
+    description: `Custom component: ${pascalName}`,
+    propsSchema: options.dataBound ? {
+      contentId: {
+        type: "content",
+        description: "Target content ID",
+        required: true
+      },
+      title: {
+        type: "string",
+        description: "Title",
+        required: false
+      }
+    } : {
+      title: {
+        type: "string",
+        description: "Title",
+        required: false
+      },
+      children: {
+        type: "string",
+        description: "Body text",
+        required: false
+      }
+    },
+    examples: options.dataBound ? [`<${pascalName} contentId="123e4567-e89b-12d3-a456-426614174000" />`] : [`<${pascalName} title="Hello">Body</${pascalName}>`]
+  };
+  const componentCode = options.dataBound ? `interface ${pascalName}Props {
+  contentId: string
+  title?: string
+}
+
+export function ${pascalName}({ contentId, title }: ${pascalName}Props) {
+  // TODO: Resolve data by contentId and map it to presentational props.
+  return (
+    <section className="rounded-lg border p-4">
+      {title ? <h3 className="mb-2 text-lg font-semibold">{title}</h3> : null}
+      <p className="text-sm text-muted-foreground">Resolve content by ID: {contentId}</p>
+    </section>
+  )
+}
+` : `interface ${pascalName}Props {
+  title?: string
+  children?: string
+}
+
+export function ${pascalName}({ title, children }: ${pascalName}Props) {
+  return (
+    <section className="rounded-lg border p-4">
+      {title ? <h3 className="mb-2 text-lg font-semibold">{title}</h3> : null}
+      {children ? <p className="text-sm text-muted-foreground">{children}</p> : null}
+    </section>
+  )
+}
+`;
+  writeFileSync(definitionPath, `${JSON.stringify(definition, null, 2)}
+`, "utf-8");
+  writeFileSync(componentPath, componentCode, "utf-8");
+  ensureExport(indexPath, pascalName);
+  console.log(`Created: ${definitionPath}`);
+  console.log(`Created: ${componentPath}`);
+  console.log(`Updated: ${indexPath}`);
+  console.log("Next: run `cmx-sdk sync-components` to register the new definition");
+}
+
+// src/commands/codegen-check.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { extname, join as join5, relative, resolve as resolve2 } from "path";
+function stripJsonComments(input) {
+  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+}
+function stripTrailingCommas(input) {
+  return input.replace(/,\s*([}\]])/g, "$1");
+}
+function normalizePathValue(input) {
+  return input.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function collectFiles(rootDir, extensions) {
+  const files = [];
+  function walk(dir) {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      const fullPath = join5(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        if (entry === "node_modules" || entry === ".next" || entry === "dist") {
+          continue;
+        }
+        walk(fullPath);
+      } else if (extensions.has(extname(entry))) {
+        files.push(fullPath);
+      }
+    }
+  }
+  if (existsSync4(rootDir)) {
+    walk(rootDir);
+  }
+  return files;
+}
+function extractImports(code) {
+  const imports = /* @__PURE__ */ new Set();
+  const fromPattern = /from\s+["']([^"']+)["']/g;
+  let match;
+  while ((match = fromPattern.exec(code)) !== null) {
+    imports.add(match[1]);
+  }
+  const dynamicImportPattern = /import\(\s*["']([^"']+)["']\s*\)/g;
+  while ((match = dynamicImportPattern.exec(code)) !== null) {
+    imports.add(match[1]);
+  }
+  return Array.from(imports);
+}
+function resolveGeneratedImport(outputDirAbs, importPath) {
+  if (importPath === "@cmx/generated") {
+    return [join5(outputDirAbs, "index.ts")];
+  }
+  const subPath = importPath.replace(/^@cmx\/generated\//, "");
+  return [
+    join5(outputDirAbs, `${subPath}.ts`),
+    join5(outputDirAbs, subPath, "index.ts")
+  ];
+}
+async function runCodegenCheck(options = {}) {
+  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
+  const outputDirAbs = resolve2(projectRoot, options.outputDir ?? "cmx/generated");
+  const srcDirAbs = resolve2(projectRoot, options.srcDir ?? "src");
+  const tsconfigAbs = resolve2(projectRoot, options.tsconfigPath ?? "tsconfig.json");
+  const errors = [];
+  const warnings = [];
+  const checks = [];
+  if (!existsSync4(outputDirAbs)) {
+    errors.push(`Generated output directory not found: ${relative(projectRoot, outputDirAbs)}`);
+  } else {
+    checks.push(`Generated directory exists: ${relative(projectRoot, outputDirAbs)}`);
+    const indexPath = join5(outputDirAbs, "index.ts");
+    if (!existsSync4(indexPath)) {
+      errors.push(`Generated index not found: ${relative(projectRoot, indexPath)}`);
+    } else {
+      checks.push(`Generated index exists: ${relative(projectRoot, indexPath)}`);
+    }
+  }
+  if (!existsSync4(tsconfigAbs)) {
+    errors.push(`tsconfig not found: ${relative(projectRoot, tsconfigAbs)}`);
+  } else {
+    try {
+      const raw = readFileSync4(tsconfigAbs, "utf-8");
+      const parsed = JSON.parse(stripTrailingCommas(stripJsonComments(raw)));
+      const aliasValues = parsed.compilerOptions?.paths?.["@cmx/*"] ?? [];
+      if (aliasValues.length === 0) {
+        errors.push("tsconfig compilerOptions.paths['@cmx/*'] is missing");
+      } else {
+        const normalizedAliasValues = aliasValues.map(normalizePathValue);
+        if (!normalizedAliasValues.includes("cmx/*")) {
+          errors.push(
+            "tsconfig compilerOptions.paths['@cmx/*'] must include './cmx/*' (or equivalent)"
+          );
+        } else {
+          checks.push("tsconfig '@cmx/*' alias is configured");
+        }
+      }
+      const includeValues = parsed.include ?? [];
+      const normalizedIncludeValues = includeValues.map(normalizePathValue);
+      if (!normalizedIncludeValues.includes("cmx/**/*.ts")) {
+        warnings.push("tsconfig include does not contain 'cmx/**/*.ts'");
+      } else {
+        checks.push("tsconfig include contains 'cmx/**/*.ts'");
+      }
+    } catch (error) {
+      errors.push(`Failed to parse tsconfig: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (!existsSync4(srcDirAbs)) {
+    warnings.push(`Source directory not found: ${relative(projectRoot, srcDirAbs)}`);
+  } else {
+    const sourceFiles = collectFiles(srcDirAbs, /* @__PURE__ */ new Set([".ts", ".tsx"]));
+    const legacyImportHits = [];
+    const generatedImportHits = [];
+    for (const sourceFile of sourceFiles) {
+      const code = readFileSync4(sourceFile, "utf-8");
+      const imports = extractImports(code);
+      for (const importPath of imports) {
+        if (importPath.startsWith("@/cmx/generated")) {
+          legacyImportHits.push(`${relative(projectRoot, sourceFile)} -> ${importPath}`);
+        }
+        if (importPath === "@cmx/generated" || importPath.startsWith("@cmx/generated/")) {
+          generatedImportHits.push(`${relative(projectRoot, sourceFile)} -> ${importPath}`);
+          const candidates = resolveGeneratedImport(outputDirAbs, importPath);
+          for (const candidate of candidates) {
+            if (existsSync4(candidate)) {
+              break;
+            }
+            const isLast = candidate === candidates.at(-1);
+            if (isLast) {
+              errors.push(
+                `Missing generated target for import '${importPath}' referenced in ${relative(projectRoot, sourceFile)}`
+              );
+            }
+          }
+        }
+      }
+    }
+    if (legacyImportHits.length > 0) {
+      errors.push("Legacy '@/cmx/generated' imports were found:");
+      for (const hit of legacyImportHits) {
+        errors.push(`  - ${hit}`);
+      }
+    } else {
+      checks.push("No legacy '@/cmx/generated' imports found");
+    }
+    if (generatedImportHits.length === 0) {
+      warnings.push("No '@cmx/generated' imports found under src/ (this may be expected for empty projects)");
+    } else {
+      checks.push(`Found ${generatedImportHits.length} '@cmx/generated' import(s) under src/`);
+    }
+  }
+  return {
+    success: errors.length === 0,
+    errors,
+    warnings,
+    checks
+  };
+}
+async function codegenCheck(options = {}) {
+  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
+  const result = await runCodegenCheck(options);
+  console.log("Codegen check:");
+  for (const check of result.checks) {
+    console.log(`  \u2713 ${check}`);
+  }
+  for (const warning of result.warnings) {
+    console.warn(`  \u26A0 ${warning}`);
+  }
+  for (const error of result.errors) {
+    console.error(`  \u2717 ${error}`);
+  }
+  if (!result.success) {
+    console.error(`
+Codegen check failed in ${projectRoot}`);
+    process.exit(1);
+  }
+  console.log("\nCodegen check passed");
+}
+
+// src/commands/mdx-validate.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { extname as extname2, join as join6, relative as relative2, resolve as resolve3 } from "path";
+
+// src/mdx/validator.ts
+import { compile } from "@mdx-js/mdx";
+var FORBIDDEN_PATTERNS = [
+  // import/export statements
+  { pattern: /^\s*import\s+/m, message: "import\u6587\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  { pattern: /^\s*export\s+/m, message: "export\u6587\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // JS expressions in curly braces (except component props)
+  { pattern: /\{[^}]*(?:=>|function|new\s+|typeof|instanceof)[^}]*\}/m, message: "JavaScript\u5F0F\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // eval, Function constructor
+  { pattern: /\beval\s*\(/m, message: "eval\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  { pattern: /\bnew\s+Function\s*\(/m, message: "Function constructor\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // script tags
+  { pattern: /<script[\s>]/i, message: "script\u30BF\u30B0\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // on* event handlers
+  { pattern: /\bon\w+\s*=/i, message: "\u30A4\u30D9\u30F3\u30C8\u30CF\u30F3\u30C9\u30E9\u5C5E\u6027\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // javascript: URLs
+  { pattern: /javascript\s*:/i, message: "javascript: URL\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
+  // data: URLs (for images - can be XSS vector)
+  { pattern: /src\s*=\s*["']?\s*data:/i, message: "data: URL\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" }
+];
+function extractComponents(mdx) {
+  const components = [];
+  const lines = mdx.split("\n");
+  const componentPattern = /<([A-Z][a-zA-Z0-9]*)\s*([^>]*?)\s*\/?>/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let match;
+    while ((match = componentPattern.exec(line)) !== null) {
+      const name = match[1];
+      const propsString = match[2];
+      const props = parseProps(propsString);
+      components.push({
+        name,
+        props,
+        line: i + 1
+      });
+    }
+  }
+  return components;
+}
+function parseProps(propsString) {
+  const props = {};
+  const propPattern = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([^}]*)\})/g;
+  let match;
+  while ((match = propPattern.exec(propsString)) !== null) {
+    const key = match[1];
+    const stringValue = match[2] ?? match[3];
+    const expressionValue = match[4];
+    if (stringValue !== void 0) {
+      props[key] = stringValue;
+    } else if (expressionValue !== void 0) {
+      const trimmed = expressionValue.trim();
+      if (trimmed === "true") {
+        props[key] = true;
+      } else if (trimmed === "false") {
+        props[key] = false;
+      } else if (/^\d+$/.test(trimmed)) {
+        props[key] = parseInt(trimmed, 10);
+      } else if (/^\d+\.\d+$/.test(trimmed)) {
+        props[key] = parseFloat(trimmed);
+      } else if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+          props[key] = JSON.parse(trimmed.replace(/'/g, '"'));
+        } catch {
+          props[key] = trimmed;
+        }
+      } else {
+        props[key] = trimmed;
+      }
+    }
+  }
+  const booleanPattern = /(?:^|\s)(\w+)(?=\s|\/|>|$)/g;
+  while ((match = booleanPattern.exec(propsString)) !== null) {
+    const key = match[1];
+    if (!(key in props)) {
+      props[key] = true;
+    }
+  }
+  return props;
+}
+function extractReferences(components) {
+  const contentIds = [];
+  const assetIds = [];
+  for (const component of components) {
+    if (component.name === "BlogCard" && typeof component.props.contentId === "string") {
+      contentIds.push(component.props.contentId);
+    }
+    if (component.name === "Image" && typeof component.props.assetId === "string") {
+      assetIds.push(component.props.assetId);
+    }
+  }
+  return {
+    contentIds: [...new Set(contentIds)],
+    assetIds: [...new Set(assetIds)]
+  };
+}
+async function validateMdx(mdx) {
+  const errors = [];
+  const warnings = [];
+  for (const { pattern, message } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(mdx)) {
+      const lines = mdx.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        if (pattern.test(lines[i])) {
+          errors.push({
+            type: "forbidden",
+            message,
+            line: i + 1
+          });
+          break;
+        }
+      }
+    }
+  }
+  try {
+    await compile(mdx, {
+      development: false
+      // Minimal compilation to check syntax
+    });
+  } catch (error) {
+    const err = error;
+    errors.push({
+      type: "syntax",
+      message: err.message,
+      line: err.line,
+      column: err.column
+    });
+  }
+  const components = extractComponents(mdx);
+  for (const component of components) {
+    if (!isValidComponent(component.name)) {
+      errors.push({
+        type: "component",
+        message: `\u672A\u77E5\u306E\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8: ${component.name}`,
+        line: component.line,
+        component: component.name
+      });
+      continue;
+    }
+    const result = validateComponentProps(component.name, component.props);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        errors.push({
+          type: "props",
+          message: `${component.name}: ${issue.path.join(".")} - ${issue.message}`,
+          line: component.line,
+          component: component.name
+        });
+      }
+    }
+  }
+  const references = extractReferences(components);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    references
+  };
+}
+
+// src/commands/mdx-validate.ts
+function collectMdxFiles(rootDir) {
+  const files = [];
+  function walk(dir) {
+    const entries = readdirSync3(dir);
+    for (const entry of entries) {
+      const fullPath = join6(dir, entry);
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        if (entry === "node_modules" || entry === ".git" || entry === ".next" || entry === "dist") {
+          continue;
+        }
+        walk(fullPath);
+      } else if (extname2(entry) === ".mdx") {
+        files.push(fullPath);
+      }
+    }
+  }
+  if (existsSync5(rootDir)) {
+    walk(rootDir);
+  }
+  return files;
+}
+async function mdxValidate(options) {
+  const projectRoot = process.cwd();
+  const inputFile = options.file ? resolve3(projectRoot, options.file) : null;
+  const inputDir = resolve3(projectRoot, options.dir ?? "src");
+  const targets = [];
+  if (inputFile) {
+    if (!existsSync5(inputFile)) {
+      console.error(`Error: file not found: ${options.file}`);
+      process.exit(1);
+    }
+    targets.push(inputFile);
+  } else {
+    const dirFiles = collectMdxFiles(inputDir);
+    targets.push(...dirFiles);
+  }
+  if (targets.length === 0) {
+    console.error("No MDX files found to validate");
+    process.exit(1);
+  }
+  let invalidCount = 0;
+  let warningCount = 0;
+  for (const filePath of targets) {
+    const mdx = readFileSync5(filePath, "utf-8");
+    const result = await validateMdx(mdx);
+    const relPath = relative2(projectRoot, filePath);
+    if (result.valid) {
+      console.log(`\u2713 ${relPath}`);
+    } else {
+      invalidCount++;
+      console.log(`\u2717 ${relPath}`);
+      for (const err of result.errors) {
+        const location = err.line ? `:${err.line}${err.column ? `:${err.column}` : ""}` : "";
+        console.log(`  - [${err.type}]${location} ${err.message}`);
+      }
+    }
+    if (result.warnings.length > 0) {
+      warningCount += result.warnings.length;
+      for (const warning of result.warnings) {
+        console.log(`  ! [warning] ${warning}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(`Validated ${targets.length} file(s)`);
+  console.log(`Invalid: ${invalidCount}`);
+  console.log(`Warnings: ${warningCount}`);
+  if (invalidCount > 0) {
+    process.exit(1);
+  }
+}
+
+// src/commands/mdx-doctor.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { basename, extname as extname3, join as join7, relative as relative3, resolve as resolve4 } from "path";
+function collectFiles2(rootDir, extension) {
+  const files = [];
+  function walk(dir) {
+    const entries = readdirSync4(dir);
+    for (const entry of entries) {
+      const fullPath = join7(dir, entry);
+      const stat = statSync3(fullPath);
+      if (stat.isDirectory()) {
+        if (entry === "node_modules" || entry === ".git" || entry === ".next" || entry === "dist") {
+          continue;
+        }
+        walk(fullPath);
+      } else if (extname3(entry) === extension) {
+        files.push(fullPath);
+      }
+    }
+  }
+  if (existsSync6(rootDir)) {
+    walk(rootDir);
+  }
+  return files;
+}
+function parseDefinitionFiles(projectRoot, files) {
+  const definitions = [];
+  const errors = [];
+  for (const file of files) {
+    try {
+      const raw = readFileSync6(file, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.name !== "string" || parsed.name.length === 0) {
+        errors.push(`${relative3(projectRoot, file)}: missing string 'name'`);
+        continue;
+      }
+      definitions.push({ name: parsed.name, file });
+    } catch (error) {
+      errors.push(
+        `${relative3(projectRoot, file)}: invalid JSON (${error instanceof Error ? error.message : String(error)})`
+      );
+    }
+  }
+  return { definitions, errors };
+}
+function collectExportedComponentNames(indexContent) {
+  const exported = /* @__PURE__ */ new Set();
+  const namedExportPattern = /export\s+\{\s*([A-Za-z0-9_]+)(?:\s+as\s+[A-Za-z0-9_]+)?\s*\}\s+from\s+["']\.\/?([^"']+)["']/g;
+  let match;
+  while ((match = namedExportPattern.exec(indexContent)) !== null) {
+    exported.add(match[1]);
+    const pathBase = basename(match[2]);
+    exported.add(pathBase);
+  }
+  const exportAllPattern = /export\s+\*\s+from\s+["']\.\/?([^"']+)["']/g;
+  while ((match = exportAllPattern.exec(indexContent)) !== null) {
+    exported.add(basename(match[1]));
+  }
+  return exported;
+}
+async function mdxDoctor(options = {}) {
+  const projectRoot = process.cwd();
+  const definitionsDir = resolve4(projectRoot, options.definitionsDir ?? "cmx/components");
+  const componentsDir = resolve4(projectRoot, options.componentsDir ?? "src/components/custom");
+  const indexFile = resolve4(projectRoot, options.indexFile ?? join7(options.componentsDir ?? "src/components/custom", "index.ts"));
+  const issues = [];
+  const checks = [];
+  if (!existsSync6(definitionsDir)) {
+    issues.push(`Definitions directory not found: ${relative3(projectRoot, definitionsDir)}`);
+  }
+  if (!existsSync6(componentsDir)) {
+    issues.push(`Components directory not found: ${relative3(projectRoot, componentsDir)}`);
+  }
+  if (issues.length > 0) {
+    for (const issue of issues) {
+      console.error(`\u2717 ${issue}`);
+    }
+    process.exit(1);
+  }
+  const definitionFiles = collectFiles2(definitionsDir, ".json");
+  const implFiles = collectFiles2(componentsDir, ".tsx").filter((f) => basename(f) !== "index.tsx");
+  checks.push(`Found ${definitionFiles.length} definition file(s)`);
+  checks.push(`Found ${implFiles.length} implementation file(s)`);
+  const { definitions, errors } = parseDefinitionFiles(projectRoot, definitionFiles);
+  for (const error of errors) {
+    issues.push(error);
+  }
+  const definitionNames = new Set(definitions.map((d) => d.name));
+  const implementationNames = new Set(
+    implFiles.map((f) => basename(f, ".tsx")).filter((name) => name !== "index")
+  );
+  for (const def of definitions) {
+    if (isStandardComponentName(def.name)) {
+      issues.push(`${relative3(projectRoot, def.file)}: '${def.name}' is reserved as a standard component`);
+    }
+  }
+  for (const defName of definitionNames) {
+    if (!implementationNames.has(defName)) {
+      issues.push(`Definition exists but implementation is missing: ${defName}.tsx`);
+    }
+  }
+  for (const implName of implementationNames) {
+    if (!definitionNames.has(implName)) {
+      issues.push(`Implementation exists but definition is missing: ${implName}.json`);
+    }
+  }
+  if (!existsSync6(indexFile)) {
+    issues.push(`Export index not found: ${relative3(projectRoot, indexFile)}`);
+  } else {
+    const indexContent = readFileSync6(indexFile, "utf-8");
+    const exportedNames = collectExportedComponentNames(indexContent);
+    for (const implName of implementationNames) {
+      if (!exportedNames.has(implName)) {
+        issues.push(`Implementation is not exported in ${relative3(projectRoot, indexFile)}: ${implName}`);
+      }
+    }
+    checks.push(`Checked exports in ${relative3(projectRoot, indexFile)}`);
+  }
+  console.log("MDX doctor:");
+  for (const check of checks) {
+    console.log(`  \u2713 ${check}`);
+  }
+  if (issues.length > 0) {
+    for (const issue of issues) {
+      console.error(`  \u2717 ${issue}`);
+    }
+    console.error(`
+Doctor found ${issues.length} issue(s)`);
+    process.exit(1);
+  }
+  console.log("\nDoctor checks passed");
+}
+
 // src/cli.ts
 config();
 var program = new Command();
-program.name("cmx-sdk").description("CMX SDK - CLI tool for managing CMX schemas and content").version("0.1.13");
+program.name("cmx-sdk").description("CMX SDK - CLI tool for managing CMX schemas and content").version("0.2.3").allowExcessArguments(false);
+function requireApiCredentials() {
+  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 { apiUrl, apiKey };
+}
 program.action(async () => {
-  const { interactiveMenu } = await import("./interactive-menu-BAMWXEKP.js");
+  const { interactiveMenu } = await import("./interactive-menu-BDZOOGQH.js");
   await interactiveMenu();
 });
 program.command("init [project-name]").description("\u65B0\u898F CMX \u30B5\u30A4\u30C8\u3092\u4F5C\u6210").option("--no-studio", "CMX Studio \u3092\u30B9\u30AD\u30C3\u30D7").option("--pm <manager>", "\u30D1\u30C3\u30B1\u30FC\u30B8\u30DE\u30CD\u30FC\u30B8\u30E3\u30FC (npm, pnpm, yarn)").action(async (projectName, options) => {
-  const { init } = await import("./init-OD2XGZI2.js");
+  const { init } = await import("./init-XUTF5IBZ.js");
   await init(projectName, options);
 });
 program.command("add-studio").description("\u65E2\u5B58\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306B CMX Studio \u3092\u8FFD\u52A0").action(async () => {
-  const { addStudio } = await import("./add-studio-C2L2NYQC.js");
+  const { addStudio } = await import("./add-studio-TLDFTZTX.js");
   await addStudio();
 });
+program.command("studio").description("\u30B5\u30A4\u30C8 (4000) \u3068 Studio (4001) \u3092\u540C\u6642\u8D77\u52D5").action(studio);
 program.command("list-collections").description("List all collections").action(listCollections);
 program.command("list-data-types").description("List all data types").action(listDataTypes);
 program.command("list-forms").description("List all form definitions").action(listForms);
@@ -1953,20 +3312,75 @@ 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").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({
+program.command("sync-components").description("Sync custom components").action(syncComponents);
+program.command("components").description("Manage custom component definitions and templates").command("scaffold").description("Generate component definition + implementation scaffold").requiredOption("--name <name>", "Component name (PascalCase)").option("--data-bound", "Generate data-bound template with ID resolver props").option("--force", "Overwrite existing files").option("--components-dir <dir>", "Custom components directory (default: src/components/custom)").option("--definitions-dir <dir>", "Component definition directory (default: cmx/components)").action((options) => scaffoldComponent(options));
+var codegenCommand = program.command("codegen").description("Generate typed code, page scaffolds, and run compatibility checks");
+codegenCommand.command("types").description("Generate TypeScript types and fetch helpers from CMX schema").option("--output <dir>", "Output directory", "cmx/generated").action(async (options) => {
+  const { apiUrl, apiKey } = requireApiCredentials();
+  await generate({
     apiUrl,
     apiKey,
-    outputDir: options.output || "cmx/generated"
+    outputDir: options.output
   });
 });
+codegenCommand.command("pages").description("Generate Next.js pages from CMX schema").option("--app-dir <dir>", "App directory path", "src/app").option("--features-dir <dir>", "Features directory path (layered template only)", "src/features").option("--template <template>", "Template style: layered or legacy", "layered").option("--dry-run", "Preview without writing files").option("--force", "Overwrite existing files").option("--only <filter>", "Scaffold only specific items (e.g. collections:blog)").action(
+  async (options) => {
+    const { apiUrl, apiKey } = requireApiCredentials();
+    await scaffold({
+      apiUrl,
+      apiKey,
+      appDir: options.appDir,
+      featuresDir: options.featuresDir,
+      template: options.template,
+      dryRun: options.dryRun,
+      force: options.force,
+      only: options.only
+    });
+  }
+);
+codegenCommand.command("check").description("Check generated code and project wiring consistency").option("--project-root <dir>", "Project root directory").option("--output-dir <dir>", "Generated output directory", "cmx/generated").option("--src-dir <dir>", "Source directory to scan imports", "src").option("--tsconfig <path>", "Path to tsconfig", "tsconfig.json").action(
+  async (options) => {
+    await codegenCheck({
+      projectRoot: options.projectRoot,
+      outputDir: options.outputDir,
+      srcDir: options.srcDir,
+      tsconfigPath: options.tsconfig
+    });
+  }
+);
+codegenCommand.command("all").description("Run `codegen types`, `codegen pages`, and `codegen check` in sequence").option("--output <dir>", "Output directory for generated types", "cmx/generated").option("--app-dir <dir>", "App directory path", "src/app").option("--features-dir <dir>", "Features directory path (layered template only)", "src/features").option("--template <template>", "Template style: layered or legacy", "layered").option("--dry-run", "Preview page generation without writing files").option("--force", "Overwrite existing files when generating pages").option("--only <filter>", "Scaffold only specific items (e.g. collections:blog)").option("--src-dir <dir>", "Source directory to scan imports", "src").option("--tsconfig <path>", "Path to tsconfig", "tsconfig.json").action(
+  async (options) => {
+    const { apiUrl, apiKey } = requireApiCredentials();
+    console.log("\n[1/3] codegen types");
+    await generate({
+      apiUrl,
+      apiKey,
+      outputDir: options.output
+    });
+    console.log("\n[2/3] codegen pages");
+    await scaffold({
+      apiUrl,
+      apiKey,
+      appDir: options.appDir,
+      featuresDir: options.featuresDir,
+      template: options.template,
+      dryRun: options.dryRun,
+      force: options.force,
+      only: options.only
+    });
+    console.log("\n[3/3] codegen check");
+    await codegenCheck({
+      outputDir: options.output,
+      srcDir: options.srcDir,
+      tsconfigPath: options.tsconfig
+    });
+  }
+);
+var mdxCommand = program.command("mdx").description("MDX developer tooling");
+mdxCommand.command("validate").description("Validate MDX files for syntax, forbidden patterns, and component usage").option("--file <path>", "Validate a single file").option("--dir <dir>", "Validate all .mdx files under a directory", "src").action((options) => mdxValidate(options));
+mdxCommand.command("doctor").description("Check consistency between MDX component definitions and implementations").option("--definitions-dir <dir>", "Definitions directory", "cmx/components").option("--components-dir <dir>", "Component implementation directory", "src/components/custom").option("--index-file <path>", "Component export index file", "src/components/custom/index.ts").action(
+  (options) => mdxDoctor(options)
+);
 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);
@@ -1978,22 +3392,6 @@ program.command("add-collection-data-type").description("Add a data type to a co
 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.command("list-data-entries").description("List data entries for a data type").requiredOption("--type-slug <slug>", "Data type slug").option("--sort-by <field>", "Sort by field").option("--sort-order <order>", "Sort order (asc or desc)").option("--limit <number>", "Maximum number of entries").option("--offset <number>", "Number of entries to skip").option("--status <status>", "Filter by status (draft or published)").action(listDataEntries);
 program.command("get-data-entry").description("Get a single data entry").requiredOption("--type-slug <slug>", "Data type slug").requiredOption("--id <id>", "Data entry ID").action(getDataEntry);