@riverbankcms/sdk 0.4.3 → 0.5.1

package/dist/cli/index.js

@@ -1,14 +1,107 @@
 #!/usr/bin/env node
 'use strict';
 
+var jiti = require('jiti');
+var path9 = require('path');
+var fs = require('fs');
 var dotenv = require('dotenv');
 var commander = require('commander');
 var zod = require('zod');
-var jiti = require('jiti');
-var path = require('path');
-var fs = require('fs');
+var prompts = require('prompts');
+var fs3 = require('fs/promises');
+var readline = require('readline');
+var equal = require('fast-deep-equal');
+var os = require('os');
+var child_process = require('child_process');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
+var prompts__default = /*#__PURE__*/_interopDefault(prompts);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
+var equal__default = /*#__PURE__*/_interopDefault(equal);
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/load-config.ts
+var load_config_exports = {};
+__export(load_config_exports, {
+  loadConfigFile: () => loadConfigFile
+});
+async function loadConfigFile(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(
+      `Config file not found: ${resolvedPath}
+Create a riverbank.config.ts file or specify a path with --config`
+    );
+  }
+  console.log(`Loading config from ${resolvedPath}...`);
+  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)), {
+    // Disable caching for CLI tool
+    fsCache: false,
+    moduleCache: false
+  });
+  try {
+    const configModule = await jiti$1.import(resolvedPath);
+    const config3 = configModule.default ?? configModule.config ?? configModule;
+    if (!config3 || typeof config3 !== "object") {
+      throw new Error("Config file must export a configuration object");
+    }
+    return config3;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to load config: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function resolveConfigPath(configPath) {
+  if (!configPath) {
+    return path9.resolve(process.cwd(), DEFAULT_CONFIG_FILENAME);
+  }
+  const resolved = path9.resolve(configPath);
+  if (fs.existsSync(resolved) && !resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
+    return path9.resolve(resolved, DEFAULT_CONFIG_FILENAME);
+  }
+  return resolved;
+}
+var DEFAULT_CONFIG_FILENAME;
+var init_load_config = __esm({
+  "src/cli/load-config.ts"() {
+    DEFAULT_CONFIG_FILENAME = "riverbank.config.ts";
+  }
+});
+
 // ../blocks/src/system/manifest/augmentManifest.ts
 function augmentManifest(manifest) {
   let augmentedFields = manifest.fields ?? [];
@@ -481,11 +574,11 @@ function bind(from, options) {
     }
   });
 }
-function when(path, options) {
+function when(path11, options) {
   return (node) => ({
     ...node,
     $when: {
-      when: { from: path },
+      when: { from: path11 },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
       ...options?.not ? { not: true } : {}
     }
@@ -558,25 +651,25 @@ function devValidate(node) {
 }
 
 // ../blocks/src/system/node/fragments/backgroundLayer.ts
-function backgroundLayer(path, options = {}) {
+function backgroundLayer(path11, options = {}) {
   const {
     styleClassName = "absolute inset-0 -z-10 h-full w-full pointer-events-none",
     imageClassName
   } = options;
   const styleLayer = el("div", {
-    className: { $bind: { from: path, transforms: [{ id: "background.resolveClass", options: { baseClass: styleClassName } }] } },
-    style: { $bind: { from: path, transforms: [{ id: "background.resolveStyle" }] } }
+    className: { $bind: { from: path11, transforms: [{ id: "background.resolveClass", options: { baseClass: styleClassName } }] } },
+    style: { $bind: { from: path11, transforms: [{ id: "background.resolveStyle" }] } }
   });
-  const imageLayer = createBackgroundImageNode(path, imageClassName);
+  const imageLayer = createBackgroundImageNode(path11, imageClassName);
   return [styleLayer, imageLayer];
 }
-function createBackgroundImageNode(path, baseClassName = "absolute -z-10") {
-  const imagePath = `${path}.image`;
+function createBackgroundImageNode(path11, baseClassName = "absolute -z-10") {
+  const imagePath = `${path11}.image`;
   return media(
     {
       className: {
         $bind: {
-          from: path,
+          from: path11,
           transforms: [{
             id: "background.resolveImageClassName",
             options: { baseClass: `background-image ${baseClassName}` }
@@ -585,7 +678,7 @@ function createBackgroundImageNode(path, baseClassName = "absolute -z-10") {
       },
       style: {
         $bind: {
-          from: path,
+          from: path11,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       }
@@ -604,7 +697,7 @@ function parseToken(source) {
   if (source.includes("/")) {
     const [token, opacity] = source.split("/");
     const alpha = Number(opacity) / 100;
-    if (!Number.isNaN(alpha)) {
+    if (!Number.isNaN(alpha) && token) {
       return { token, alpha };
     }
     return { token: source };
@@ -644,7 +737,8 @@ function headingGroup(opts) {
     containerClass = "text-center",
     className,
     eyebrowClass = "heading-eyebrow text-sm font-semibold tracking-wide",
-    titleClass = "heading-title text-3xl font-semibold sm:text-4xl",
+    // h2 now gets size/weight from theme typography CSS
+    titleClass = "heading-title",
     eyebrowStyle = textColorStyle("neutral-500"),
     titleStyle = textColorStyle("neutral-900")
   } = opts;
@@ -686,7 +780,7 @@ function sectionContainer(children, opts) {
 var DEFAULT_SECTION_SPACING = "medium";
 
 // ../blocks/src/system/node/fragments/styledSection.ts
-function styledSection(config2) {
+function styledSection(config3) {
   const {
     children,
     baseClass = "px-6",
@@ -694,7 +788,7 @@ function styledSection(config2) {
     background = "background/base",
     bindFrom = "_sectionStyles",
     imageClassName = "absolute -z-10"
-  } = config2;
+  } = config3;
   const backgroundNodes = backgroundLayer(`${bindFrom}.background`, {
     imageClassName
   });
@@ -835,8 +929,8 @@ var FragmentConfigError = class extends Error {
     this.name = "FragmentConfigError";
   }
 };
-function defineFragment(config2) {
-  const parsed = fragmentConfigSchema.parse(config2);
+function defineFragment(config3) {
+  const parsed = fragmentConfigSchema.parse(config3);
   validateFieldDefinitions(parsed.fields, parsed.id);
   return {
     ...parsed,
@@ -1012,27 +1106,27 @@ function scopePropValue(value, scope) {
   }
   return value;
 }
-function scopeContentPath(path, scope) {
+function scopeContentPath(path11, scope) {
   if (!scope || scope.length === 0) {
-    return path;
+    return path11;
   }
-  if (path === "content") {
+  if (path11 === "content") {
     return `content.${scope}`;
   }
-  if (path.startsWith("content.")) {
-    const remainder = path.slice("content.".length);
+  if (path11.startsWith("content.")) {
+    const remainder = path11.slice("content.".length);
     return remainder.length > 0 ? `content.${scope}.${remainder}` : `content.${scope}`;
   }
-  if (path.startsWith("content[")) {
-    return path.replace(/^content/, `content.${scope}`);
+  if (path11.startsWith("content[")) {
+    return path11.replace(/^content/, `content.${scope}`);
   }
-  if (path.startsWith("$root.")) {
-    return path;
+  if (path11.startsWith("$root.")) {
+    return path11;
   }
-  if (path.includes(".")) {
-    return path;
+  if (path11.includes(".")) {
+    return path11;
   }
-  return `content.${scope}.${path}`;
+  return `content.${scope}.${path11}`;
 }
 
 // ../blocks/src/system/fragments/builder.ts
@@ -1043,26 +1137,26 @@ var FragmentCompositionError = class extends Error {
   }
 };
 var DOT_SCOPE_REGEX = /^[A-Za-z0-9_.-]*$/;
-function materializeFragment(config2) {
-  const scope = normalizeScope(config2.scope);
-  const fields4 = scopeFragmentFields(config2.fragment, scope);
-  const layout = scopeFragmentLayout(config2.fragment, scope);
-  const fieldPriority = config2.fieldPriority ?? 0;
+function materializeFragment(config3) {
+  const scope = normalizeScope(config3.scope);
+  const fields4 = scopeFragmentFields(config3.fragment, scope);
+  const layout = scopeFragmentLayout(config3.fragment, scope);
+  const fieldPriority = config3.fieldPriority ?? 0;
   let data;
-  if (config2.fragment.data) {
-    const key = config2.dataKey ?? config2.fragment.data.key;
+  if (config3.fragment.data) {
+    const key = config3.dataKey ?? config3.fragment.data.key;
     if (!key || typeof key !== "string") {
       throw new FragmentCompositionError(
-        `Fragment "${config2.fragment.id}" requires a data key to compose.`
+        `Fragment "${config3.fragment.id}" requires a data key to compose.`
       );
     }
     data = {
       key,
-      loader: config2.fragment.data.loader ? { ...config2.fragment.data.loader } : void 0
+      loader: config3.fragment.data.loader ? { ...config3.fragment.data.loader } : void 0
     };
   }
   return {
-    fragment: config2.fragment,
+    fragment: config3.fragment,
     scope,
     fields: fields4,
     layout,
@@ -1185,6 +1279,8 @@ var bodyCopyFragment = defineFragment({
       text(
         {
           as: "h2",
+          // h2 now gets size/weight from theme typography CSS
+          // Only dynamic class here is for text alignment
           className: {
             $bind: {
               from: "content.alignment",
@@ -1192,11 +1288,11 @@ var bodyCopyFragment = defineFragment({
                 {
                   id: "ui.headingClassFromAlignment",
                   options: {
-                    base: "text-3xl font-semibold sm:text-4xl"
+                    base: ""
                   }
                 }
               ],
-              fallback: "text-3xl font-semibold sm:text-4xl"
+              fallback: ""
             }
           },
           style: textColorStyle("neutral-900")
@@ -1269,7 +1365,9 @@ var heroCopyFragment = defineFragment({
     text(
       {
         as: "h1",
-        className: "hero-headline text-4xl font-semibold sm:text-5xl md:text-6xl",
+        // heading-display: uses fluid typography from theme (--fs-h1-display-fluid)
+        // Removes hardcoded text-4xl/5xl/6xl - size now controlled by theme
+        className: "hero-headline heading-display",
         style: textColorStyle("neutral-900")
       },
       bind("content.headline")
@@ -1448,7 +1546,8 @@ var testimonialsHeadingFragment = defineFragment({
       { gap: "md", className: "mx-auto max-w-2xl text-center" },
       [
         text(
-          { as: "h2", className: "text-3xl font-semibold sm:text-4xl", style: textColorStyle("neutral-900") },
+          // h2 now gets size/weight from theme typography CSS
+          { as: "h2", style: textColorStyle("neutral-900") },
           when("content.heading"),
           bind("content.heading")
         ),
@@ -1820,7 +1919,7 @@ var blogFeaturedPostFragment = defineFragment({
           text(
             {
               as: "h2",
-              className: "text-2xl font-semibold md:text-3xl",
+              // h2 now gets size/weight from theme typography CSS
               style: textColorStyle("neutral-900")
             },
             bind("title", { fallback: "Latest post" })
@@ -2217,7 +2316,8 @@ var faqHeadingFragment = defineFragment({
       text(
         {
           as: "h2",
-          className: "faq-title text-3xl font-semibold sm:text-4xl",
+          // h2 now gets size/weight from theme typography CSS
+          className: "faq-title",
           style: textColorStyle("neutral-900")
         },
         when("content.title"),
@@ -2846,13 +2946,13 @@ function sectionStylesField(options = {}) {
 }
 
 // ../blocks/src/system/defineBlock.ts
-function createBlockManifest(config2) {
-  const composition2 = config2.fragments ? composeFragments(config2.fragments) : { fields: []};
+function createBlockManifest(config3) {
+  const composition2 = config3.fragments ? composeFragments(config3.fragments) : { fields: []};
   const allFields = [
     ...composition2.fields,
-    ...config2.additionalFields ?? []
+    ...config3.additionalFields ?? []
   ];
-  if (!config2.skipSectionStyles) {
+  if (!config3.skipSectionStyles) {
     allFields.push(
       sectionStylesField({
         id: "_sectionStyles",
@@ -2861,36 +2961,36 @@ function createBlockManifest(config2) {
     );
   }
   const fields4 = fieldSchema.array().parse(allFields);
-  const layout = config2.layout;
-  const variants = config2.variants;
-  let behaviours = config2.behaviours;
-  if (!behaviours && config2.paletteHidden !== void 0) {
+  const layout = config3.layout;
+  const variants = config3.variants;
+  let behaviours = config3.behaviours;
+  if (!behaviours && config3.paletteHidden !== void 0) {
     behaviours = {
       supportsThemeSwitching: true,
       inlineEditing: true,
       animation: true,
-      paletteHidden: config2.paletteHidden
+      paletteHidden: config3.paletteHidden
     };
   }
   const manifest = {
-    name: config2.id,
+    name: config3.id,
     version: "0.1.0",
-    title: config2.title,
-    titleSource: config2.titleSource,
-    description: config2.description ?? "",
-    component: config2.component ?? deriveComponentName(config2.id),
+    title: config3.title,
+    titleSource: config3.titleSource,
+    description: config3.description ?? "",
+    component: config3.component ?? deriveComponentName(config3.id),
     fields: fields4,
     slots: [],
     // Always empty
-    styleTokens: config2.styleTokens,
+    styleTokens: config3.styleTokens,
     behaviours,
-    category: config2.category,
-    contentTypes: config2.contentTypes,
-    tags: config2.tags ?? [],
-    icon: config2.icon ?? "Box",
+    category: config3.category,
+    contentTypes: config3.contentTypes,
+    tags: config3.tags ?? [],
+    icon: config3.icon ?? "Box",
     layout,
     variants,
-    defaultVariant: config2.defaultVariant
+    defaultVariant: config3.defaultVariant
   };
   return augmentManifest(manifest);
 }
@@ -3591,7 +3691,11 @@ var simpleFooterLayout = stack(
     }
   },
   [
-    navRow({ align: "center", className: "flex flex-wrap justify-center gap-x-6 gap-y-3" }),
+    navRow({
+      align: "center",
+      className: "flex flex-wrap justify-center gap-x-6 gap-y-3",
+      linkClassName: "footer-nav-link inline-flex items-center px-4 py-2 text-sm font-medium transition-theme-standard"
+    }),
     ...bottomTextLayout()
   ],
   when("$root.theme.footer.variant", { equals: "simple" })
@@ -3619,7 +3723,11 @@ var columnsFooterLayout = stack(
       { className: "flex w-full flex-wrap items-center justify-between gap-4" },
       [
         text({ as: "span", className: "text-sm font-semibold", style: textColorStyle("text") }, bind("site.title", { fallback: "Your Site" })),
-        navRow({ className: "flex flex-wrap justify-end gap-x-6 gap-y-3", align: "end" })
+        navRow({
+          className: "flex flex-wrap justify-end gap-x-6 gap-y-3",
+          align: "end",
+          linkClassName: "footer-nav-link inline-flex items-center px-4 py-2 text-sm font-medium transition-theme-standard"
+        })
       ]
     ),
     ...bottomTextLayout()
@@ -4840,6 +4948,10 @@ function getBlockDefinition(name) {
   ensureDefaults();
   return blockStore.get(name);
 }
+function listBlockDefinitions() {
+  ensureDefaults();
+  return Array.from(blockStore.values());
+}
 
 // ../blocks/src/system/constants/blockKinds.ts
 var SYSTEM_BLOCK_KINDS = [
@@ -5021,7 +5133,7 @@ var contentConfigSchema = contentConfigBaseSchema.superRefine((data, ctx) => {
       });
     }
     const paths = data.pages.map((p) => p.path);
-    const duplicatePaths = paths.filter((path, i) => paths.indexOf(path) !== i);
+    const duplicatePaths = paths.filter((path11, i) => paths.indexOf(path11) !== i);
     if (duplicatePaths.length > 0) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
@@ -5083,6 +5195,15 @@ var sdkThemePaletteSchema = zod.z.record(zod.z.string(), zod.z.string());
 var sdkThemeConfigSchema = zod.z.object({
   palette: sdkThemePaletteSchema
 });
+var sdkSiteUrlSchema = zod.z.string().url("Must be a valid URL").refine((url) => {
+  try {
+    const parsed = new URL(url);
+    const isLocal = ["localhost", "lvh.me"].includes(parsed.hostname) || parsed.hostname.endsWith(".local") || parsed.hostname.endsWith(".test") || parsed.hostname.endsWith(".lvh.me");
+    return parsed.protocol === "https:" || isLocal;
+  } catch {
+    return false;
+  }
+}, { message: "Production URLs must use HTTPS" }).transform((url) => url.replace(/\/$/, ""));
 var sectionBackgroundSchema = zod.z.object({
   id: zod.z.string(),
   label: zod.z.string(),
@@ -5216,6 +5337,10 @@ function validateFieldIdConflicts(blockFieldExtensions) {
   }
   return conflicts;
 }
+var syncConfigSchema = zod.z.object({
+  existingEntries: zod.z.enum(["skip", "update"]).optional(),
+  contentTarget: zod.z.enum(["draft", "publish"]).optional()
+}).optional();
 var sdkCustomBlockSchema = zod.z.object({
   // Block ID must start with 'custom.'
   id: zod.z.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
@@ -5244,6 +5369,8 @@ var sdkCustomBlockSchema = zod.z.object({
 );
 var riverbankSiteConfigSchema = zod.z.object({
   siteId: zod.z.string().uuid(),
+  previewUrl: sdkSiteUrlSchema.optional(),
+  liveUrl: sdkSiteUrlSchema.optional(),
   theme: sdkThemeConfigSchema.optional(),
   styles: siteStyleConfigSchema,
   customBlocks: zod.z.array(sdkCustomBlockSchema).max(20, "Maximum 20 custom blocks per site").refine(
@@ -5256,50 +5383,15 @@ var riverbankSiteConfigSchema = zod.z.object({
   ).optional(),
   blockFieldOptions: blockFieldOptionsSchema,
   blockFieldExtensions: blockFieldExtensionsSchema,
-  content: contentConfigSchema.optional()
+  content: contentConfigSchema.optional(),
+  // CLI-related configuration (Phase 4)
+  contentDir: zod.z.string().optional(),
+  sync: syncConfigSchema
 }).strict();
-var DEFAULT_CONFIG_FILENAME = "riverbank.config.ts";
-async function loadConfigFile(configPath) {
-  const resolvedPath = resolveConfigPath(configPath);
-  if (!fs.existsSync(resolvedPath)) {
-    throw new Error(
-      `Config file not found: ${resolvedPath}
-Create a riverbank.config.ts file or specify a path with --config`
-    );
-  }
-  console.log(`Loading config from ${resolvedPath}...`);
-  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)), {
-    // Disable caching for CLI tool
-    fsCache: false,
-    moduleCache: false
-  });
-  try {
-    const configModule = await jiti$1.import(resolvedPath);
-    const config2 = configModule.default ?? configModule.config ?? configModule;
-    if (!config2 || typeof config2 !== "object") {
-      throw new Error("Config file must export a configuration object");
-    }
-    return config2;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to load config: ${error.message}`);
-    }
-    throw error;
-  }
-}
-function resolveConfigPath(configPath) {
-  if (!configPath) {
-    return path.resolve(process.cwd(), DEFAULT_CONFIG_FILENAME);
-  }
-  const resolved = path.resolve(configPath);
-  if (fs.existsSync(resolved) && !resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
-    return path.resolve(resolved, DEFAULT_CONFIG_FILENAME);
-  }
-  return resolved;
-}
 
 // src/cli/push-config.ts
-async function pushToDashboard(dashboardUrl, siteId, apiKey, config2) {
+init_load_config();
+async function pushToDashboard(dashboardUrl, siteId, apiKey, config3) {
   const pushUrl = `${dashboardUrl}/api/sites/${siteId}/sdk-config`;
   console.log(`Pushing config to ${pushUrl}...`);
   let response;
@@ -5310,7 +5402,7 @@ async function pushToDashboard(dashboardUrl, siteId, apiKey, config2) {
         "Content-Type": "application/json",
         "X-API-Key": apiKey
       },
-      body: JSON.stringify({ config: config2 }),
+      body: JSON.stringify({ config: config3 }),
       signal: AbortSignal.timeout(3e4)
     });
   } catch (error) {
@@ -5391,18 +5483,3269 @@ Examples:
   return pushConfigAction({ ...options, dashboard });
 });
 
-// src/cli/index.ts
-dotenv.config({ path: ".env.local" });
-dotenv.config({ path: ".env" });
-var program = new commander.Command();
-program.name("riverbankcms").description("Riverbank CMS SDK CLI - sync config to dashboard").version("0.1.0").addHelpText("after", `
-Examples:
-  $ npx riverbankcms push-config --api-key $RIVERBANK_API_KEY
-  $ npx riverbankcms push-config --api-key abc123 --dashboard https://www.riverbankcms.com
+// src/client/management/http.ts
+var ManagementApiError = class extends Error {
+  constructor(message, code, details, statusCode) {
+    super(message);
+    this.name = "ManagementApiError";
+    this.code = code;
+    this.details = details;
+    this.statusCode = statusCode;
+  }
+};
+function createHttpClient(config3) {
+  const baseUrl = `${config3.dashboardUrl}/api/sdk/${config3.siteId}`;
+  const timeout = config3.timeout ?? 3e4;
+  async function request(method, path11, options) {
+    let url = `${baseUrl}${path11}`;
+    if (options?.params && Object.keys(options.params).length > 0) {
+      const searchParams = new URLSearchParams(options.params);
+      url = `${url}?${searchParams.toString()}`;
+    }
+    const headers = {
+      "Authorization": `Bearer ${config3.managementApiKey}`,
+      "Content-Type": "application/json"
+    };
+    const fetchOptions = {
+      method,
+      headers,
+      signal: AbortSignal.timeout(timeout)
+    };
+    if (options?.body && method !== "GET") {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(url, fetchOptions);
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new ManagementApiError(
+          `Request timed out after ${timeout}ms`,
+          "sdk:timeout",
+          void 0,
+          void 0
+        );
+      }
+      throw new ManagementApiError(
+        error instanceof Error ? error.message : "Network request failed",
+        "sdk:network-error",
+        void 0,
+        void 0
+      );
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      if (!response.ok) {
+        throw new ManagementApiError(
+          `Request failed with status ${response.status}`,
+          "sdk:http-error",
+          void 0,
+          response.status
+        );
+      }
+      return void 0;
+    }
+    const json = await response.json();
+    if (!response.ok || !json.success) {
+      if ("error" in json && json.error) {
+        throw new ManagementApiError(
+          json.error.message,
+          json.error.code,
+          json.error.details,
+          response.status
+        );
+      }
+      throw new ManagementApiError(
+        `Request failed with status ${response.status}`,
+        "sdk:http-error",
+        void 0,
+        response.status
+      );
+    }
+    return json.data;
+  }
+  return {
+    async get(path11, params) {
+      return request("GET", path11, { params });
+    },
+    async post(path11, body) {
+      return request("POST", path11, { body });
+    },
+    async patch(path11, body) {
+      return request("PATCH", path11, { body });
+    },
+    async delete(path11, body) {
+      await request("DELETE", path11, { body });
+    }
+  };
+}
+
+// src/client/management/entries.ts
+function createEntryOperations(http) {
+  return {
+    async list(contentType, options) {
+      const params = {};
+      if (options?.page) params.page = String(options.page);
+      if (options?.limit) params.limit = String(options.limit);
+      return http.get(
+        `/entries/${encodeURIComponent(contentType)}`,
+        params
+      );
+    },
+    async get(contentType, identifier) {
+      try {
+        return await http.get(
+          `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}`
+        );
+      } catch (error) {
+        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async upsert(input) {
+      return http.post("/entries", input);
+    },
+    async publish(contentType, identifier) {
+      await http.post(
+        `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}/publish`
+      );
+    },
+    async unpublish(contentType, identifier) {
+      await http.post(
+        `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}/unpublish`
+      );
+    },
+    async delete(contentType, identifier) {
+      await http.delete(
+        `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}`
+      );
+    }
+  };
+}
+
+// src/client/management/pages.ts
+function createPageOperations(http) {
+  return {
+    async list(options) {
+      const params = {};
+      if (options?.page) params.page = String(options.page);
+      if (options?.limit) params.limit = String(options.limit);
+      return http.get("/pages", params);
+    },
+    async get(identifier) {
+      try {
+        return await http.get(
+          `/pages/${encodeURIComponent(identifier)}`
+        );
+      } catch (error) {
+        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async upsert(input) {
+      return http.post("/pages", input);
+    },
+    async publish(identifier) {
+      await http.post(`/pages/${encodeURIComponent(identifier)}/publish`);
+    },
+    async unpublish(identifier) {
+      await http.post(`/pages/${encodeURIComponent(identifier)}/unpublish`);
+    }
+  };
+}
+
+// src/client/management/blocks.ts
+function createBlockOperations(http) {
+  return {
+    async list(pageIdentifier) {
+      const result = await http.get(
+        `/pages/${encodeURIComponent(pageIdentifier)}/blocks`
+      );
+      return result.blocks;
+    },
+    async get(pageIdentifier, blockIdentifier) {
+      try {
+        return await http.get(
+          `/pages/${encodeURIComponent(pageIdentifier)}/blocks/${encodeURIComponent(blockIdentifier)}`
+        );
+      } catch (error) {
+        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async upsert(pageIdentifier, input) {
+      return http.post(
+        `/pages/${encodeURIComponent(pageIdentifier)}/blocks`,
+        input
+      );
+    },
+    async reorder(pageIdentifier, blockIdentifiers) {
+      await http.post(
+        `/pages/${encodeURIComponent(pageIdentifier)}/blocks/reorder`,
+        { order: blockIdentifiers }
+      );
+    },
+    async delete(pageIdentifier, blockIdentifier) {
+      await http.delete(
+        `/pages/${encodeURIComponent(pageIdentifier)}/blocks/${encodeURIComponent(blockIdentifier)}`
+      );
+    }
+  };
+}
+
+// src/client/management/navigation.ts
+function createNavigationOperations(http) {
+  return {
+    async list() {
+      const result = await http.get("/navigation");
+      return result.menus;
+    },
+    async get(name) {
+      try {
+        return await http.get(
+          `/navigation/${encodeURIComponent(name)}`
+        );
+      } catch (error) {
+        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async upsert(input) {
+      return http.post("/navigation", input);
+    }
+  };
+}
+
+// src/client/management/settings.ts
+function createSettingsOperations(http) {
+  return {
+    async get() {
+      const result = await http.get("/pull/settings");
+      return result.settings;
+    },
+    async update(input) {
+      const result = await http.patch("/settings", input);
+      return result.settings;
+    }
+  };
+}
+
+// src/client/management/pull.ts
+function createPullOperations(http) {
+  return {
+    async entries(contentType, options) {
+      const params = {};
+      if (options?.page) params.page = String(options.page);
+      if (options?.limit) params.limit = String(options.limit);
+      if (contentType) {
+        return http.get(
+          `/pull/entries/${encodeURIComponent(contentType)}`,
+          params
+        );
+      }
+      return http.get("/pull/entries", params);
+    },
+    async pages() {
+      return http.get("/pull/pages");
+    },
+    async navigation() {
+      return http.get("/pull/navigation");
+    },
+    async settings() {
+      return http.get("/pull/settings");
+    },
+    async all() {
+      const [entriesResult, pagesResult, navigationResult, settingsResult] = await Promise.all([
+        http.get("/pull/entries/all"),
+        http.get("/pull/pages"),
+        http.get("/pull/navigation"),
+        http.get("/pull/settings")
+      ]);
+      return {
+        entries: entriesResult?.entries || {},
+        pages: pagesResult?.pages || [],
+        navigation: navigationResult?.menus || [],
+        settings: settingsResult?.settings || {},
+        meta: {
+          pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          entries: entriesResult?.meta?.entries,
+          truncated: entriesResult?.meta?.truncated,
+          truncationMessage: entriesResult?.meta?.truncationMessage
+        }
+      };
+    }
+  };
+}
+
+// src/client/management/preview.ts
+function createPreviewOperations(http) {
+  return {
+    async block(input) {
+      return http.post("/preview/block", input);
+    }
+  };
+}
+
+// src/client/management/identifiers.ts
+function createIdentifiersOperations(http) {
+  return {
+    async backfill() {
+      const response = await http.post("/identifiers/backfill");
+      return response.data;
+    }
+  };
+}
+
+// src/client/management/index.ts
+function createManagementClient(config3) {
+  if (!config3.dashboardUrl) {
+    throw new Error(
+      "dashboardUrl is required when creating a management client. Example: http://localhost:4000 or https://dashboard.riverbankcms.com"
+    );
+  }
+  if (!config3.managementApiKey) {
+    throw new Error(
+      "managementApiKey is required when creating a management client. A management API key starts with bld_mgmt_sk_"
+    );
+  }
+  if (!config3.managementApiKey.startsWith("bld_mgmt_sk_")) {
+    throw new Error(
+      "Invalid management API key format. A management API key must start with bld_mgmt_sk_"
+    );
+  }
+  if (!config3.siteId) {
+    throw new Error(
+      "siteId is required when creating a management client."
+    );
+  }
+  const http = createHttpClient(config3);
+  return {
+    entries: createEntryOperations(http),
+    pages: createPageOperations(http),
+    blocks: createBlockOperations(http),
+    navigation: createNavigationOperations(http),
+    settings: createSettingsOperations(http),
+    pull: createPullOperations(http),
+    preview: createPreviewOperations(http),
+    identifiers: createIdentifiersOperations(http)
+  };
+}
+
+// src/cli/env.ts
+function getEnvPrefix(target) {
+  return target === "remote" ? "RIVERBANK_REMOTE" : "RIVERBANK_LOCAL";
+}
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+function loadEnvironment(remote) {
+  const target = remote ? "remote" : "local";
+  const prefix = getEnvPrefix(target);
+  const siteId = requireEnv(`${prefix}_SITE_ID`);
+  const dashboardUrl = requireEnv(`${prefix}_DASHBOARD_URL`);
+  const managementApiKey = requireEnv(`${prefix}_MGMT_API_KEY`);
+  if (!managementApiKey.startsWith("bld_mgmt_sk_")) {
+    throw new Error(
+      `Invalid management API key format for ${prefix}_MGMT_API_KEY. Expected key starting with bld_mgmt_sk_`
+    );
+  }
+  try {
+    new URL(dashboardUrl);
+  } catch {
+    throw new Error(
+      `Invalid dashboard URL in ${prefix}_DASHBOARD_URL: ${dashboardUrl}. Expected format: http://localhost:4000 or https://dashboard.example.com`
+    );
+  }
+  return {
+    siteId,
+    dashboardUrl,
+    managementApiKey
+  };
+}
+
+// src/cli/output.ts
+function createOutput(options) {
+  const { json: jsonMode = false, quiet = false } = options;
+  return {
+    success(message, data) {
+      if (jsonMode) {
+        console.log(JSON.stringify({ success: true, message, data }, null, 2));
+      } else if (!quiet) {
+        console.log(`\u2713 ${message}`);
+        if (data !== void 0) {
+          console.log(JSON.stringify(data, null, 2));
+        }
+      }
+    },
+    error(message, details) {
+      if (jsonMode) {
+        console.error(JSON.stringify({ success: false, error: message, details }, null, 2));
+      } else {
+        console.error(`\u2717 ${message}`);
+        if (details !== void 0) {
+          if (typeof details === "object" && details !== null) {
+            console.error(JSON.stringify(details, null, 2));
+          } else {
+            console.error(String(details));
+          }
+        }
+      }
+      process.exit(1);
+    },
+    warn(message, data) {
+      if (jsonMode) {
+        console.error(JSON.stringify({ warning: message, data }, null, 2));
+      } else if (!quiet) {
+        console.warn(`\u26A0 ${message}`);
+        if (data !== void 0) {
+          console.warn(JSON.stringify(data, null, 2));
+        }
+      }
+    },
+    info(message, data) {
+      if (!jsonMode && !quiet) {
+        console.log(`\u2139 ${message}`);
+        if (data !== void 0) {
+          console.log(JSON.stringify(data, null, 2));
+        }
+      }
+    },
+    table(headers, rows) {
+      if (jsonMode) {
+        const objects = rows.map((row) => {
+          const obj = {};
+          headers.forEach((header, i) => {
+            obj[header] = row[i] ?? "";
+          });
+          return obj;
+        });
+        console.log(JSON.stringify(objects, null, 2));
+      } else if (!quiet) {
+        const widths = headers.map((h, i) => {
+          const maxRowWidth = Math.max(...rows.map((r) => (r[i] ?? "").length));
+          return Math.max(h.length, maxRowWidth);
+        });
+        const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+        const separator = widths.map((w) => "-".repeat(w)).join("  ");
+        console.log(headerRow);
+        console.log(separator);
+        for (const row of rows) {
+          const formattedRow = row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join("  ");
+          console.log(formattedRow);
+        }
+      }
+    },
+    json(data) {
+      console.log(JSON.stringify(data, null, 2));
+    },
+    progress(current, total, message) {
+      if (!jsonMode && !quiet) {
+        const percent = Math.round(current / total * 100);
+        const bar = "\u2588".repeat(Math.floor(percent / 5)) + "\u2591".repeat(20 - Math.floor(percent / 5));
+        process.stdout.write(`\r${bar} ${percent}% ${message}`);
+        if (current === total) {
+          console.log();
+        }
+      }
+    }
+  };
+}
+
+// src/cli/errors.ts
+var ErrorCodes = {
+  // Network errors
+  NETWORK_ERROR: "sdk:network-error",
+  // General errors
+  UNKNOWN: "sdk:unknown"
+};
+var errorSuggestions = {
+  "sdk:missing-env": "Check your .env.local file and ensure all RIVERBANK_* variables are set.",
+  "sdk:unauthorized": "Verify your management API key is correct and not expired.",
+  "sdk:forbidden": "Ensure your API key has the correct permissions for this operation.",
+  "sdk:missing-content-type": "Run `riverbankcms push-config` to sync your content type definitions.",
+  "sdk:unknown-block-kind": "Run `riverbankcms push-config` to sync your custom block definitions.",
+  "sdk:network-error": "Check your network connection and ensure the dashboard is accessible.",
+  "sdk:timeout": "The request timed out. Try again or check if the dashboard is responding.",
+  "auth:forbidden": "Your API key is not authorized for this site or operation.",
+  "auth:invalid": "Invalid API key. Generate a new management key from the dashboard."
+};
+function formatError(error) {
+  if (error instanceof ManagementApiError) {
+    return {
+      code: error.code,
+      message: error.message,
+      details: error.details,
+      suggestion: errorSuggestions[error.code]
+    };
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("ECONNREFUSED")) {
+      return {
+        code: ErrorCodes.NETWORK_ERROR,
+        message: "Could not connect to the dashboard",
+        details: error.message,
+        suggestion: errorSuggestions[ErrorCodes.NETWORK_ERROR]
+      };
+    }
+    if (error.message.includes("fetch failed")) {
+      return {
+        code: ErrorCodes.NETWORK_ERROR,
+        message: "Network request failed",
+        details: error.message,
+        suggestion: errorSuggestions[ErrorCodes.NETWORK_ERROR]
+      };
+    }
+    return {
+      code: ErrorCodes.UNKNOWN,
+      message: error.message
+    };
+  }
+  return {
+    code: ErrorCodes.UNKNOWN,
+    message: String(error)
+  };
+}
+
+// src/cli/helpers.ts
+function mapEntryForOutput(entry) {
+  const result = {
+    identifier: entry.identifier,
+    data: entry.data,
+    status: entry.status,
+    hasUnpublishedChanges: entry.hasUnpublishedChanges
+  };
+  if (entry.slug !== void 0) {
+    result.slug = entry.slug;
+  }
+  return result;
+}
+function parsePaginationOptions(options) {
+  return {
+    limit: parseInt(options.limit ?? "20", 10),
+    page: parseInt(options.page ?? "1", 10)
+  };
+}
+function formatDateShort(isoDate) {
+  return isoDate.split("T")[0] ?? "";
+}
+async function parseJsonData(options) {
+  if (options.file) {
+    const filePath = path9__namespace.resolve(options.file);
+    const content = await fs3__namespace.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+  if (options.data) {
+    return JSON.parse(options.data);
+  }
+  throw new Error("Either --data or --file is required");
+}
+async function parseJsonArray(options) {
+  const parsed = await parseJsonData(options);
+  if ("items" in parsed && Array.isArray(parsed.items)) {
+    return parsed.items;
+  }
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  throw new Error('Expected an array or an object with an "items" array');
+}
+async function confirmAction(message, options, isRemote) {
+  if (isRemote && !options.yes) {
+    console.error("Remote operations require --yes flag for safety");
+    return false;
+  }
+  if (options.yes) {
+    return true;
+  }
+  const rl = readline__namespace.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve8) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve8(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function createCommandContext(command) {
+  const globalOpts = command.optsWithGlobals();
+  const isRemote = globalOpts.remote ?? false;
+  const isJsonOutput = globalOpts.json ?? false;
+  const output = createOutput({
+    json: globalOpts.json,
+    quiet: globalOpts.quiet
+  });
+  const env = loadEnvironment(isRemote);
+  const client = createManagementClient({
+    dashboardUrl: env.dashboardUrl,
+    managementApiKey: env.managementApiKey,
+    siteId: env.siteId
+  });
+  return { output, client, isRemote, isJsonOutput };
+}
+function getOutputContext(command) {
+  const globalOpts = command.optsWithGlobals();
+  const isRemote = globalOpts.remote ?? false;
+  const output = createOutput({
+    json: globalOpts.json,
+    quiet: globalOpts.quiet
+  });
+  return { output, isRemote, globalOpts };
+}
+function handleCommandError(error, output) {
+  if (error instanceof SyntaxError) {
+    output.error("Invalid JSON data", { suggestion: "Check your JSON syntax" });
+    return;
+  }
+  const formatted = formatError(error);
+  output.error(formatted.message, {
+    code: formatted.code,
+    details: formatted.details,
+    suggestion: formatted.suggestion
+  });
+}
+function withErrorHandling(action) {
+  return async (...args) => {
+    const command = args[args.length - 1];
+    const { output } = getOutputContext(command);
+    try {
+      await action(...args);
+    } catch (error) {
+      handleCommandError(error, output);
+    }
+  };
+}
+function withConfirmation(getMessage, action) {
+  return async (...allArgs) => {
+    const command = allArgs[allArgs.length - 1];
+    const options = allArgs[allArgs.length - 2];
+    const args = allArgs.slice(0, -2);
+    const ctx = createCommandContext(command);
+    const { output, isRemote } = ctx;
+    const confirmed = await confirmAction(getMessage(...args), options, isRemote);
+    if (!confirmed) {
+      output.info("Operation cancelled");
+      process.exit(0);
+    }
+    try {
+      await action(ctx, ...args);
+    } catch (error) {
+      handleCommandError(error, output);
+    }
+  };
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function createPublishCommand(config3) {
+  const cmd = new commander.Command("publish").description(`Publish a ${config3.resourceName}`);
+  for (const arg of config3.args) {
+    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
+  }
+  return cmd.action(
+    withErrorHandling(async (...actionArgs) => {
+      const args = actionArgs.slice(0, config3.args.length);
+      const command = actionArgs[actionArgs.length - 1];
+      const { output, client } = createCommandContext(command);
+      const label = args.join("/");
+      output.info(`Publishing ${config3.resourceName}: ${label}`);
+      await config3.action(client, ...args);
+      output.success(`${capitalize(config3.resourceName)} published: ${label}`);
+    })
+  );
+}
+function createUnpublishCommand(config3) {
+  const cmd = new commander.Command("unpublish").description(`Unpublish a ${config3.resourceName}`);
+  for (const arg of config3.args) {
+    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
+  }
+  return cmd.action(
+    withErrorHandling(async (...actionArgs) => {
+      const args = actionArgs.slice(0, config3.args.length);
+      const command = actionArgs[actionArgs.length - 1];
+      const { output, client } = createCommandContext(command);
+      const label = args.join("/");
+      output.info(`Unpublishing ${config3.resourceName}: ${label}`);
+      await config3.action(client, ...args);
+      output.success(`${capitalize(config3.resourceName)} unpublished: ${label}`);
+    })
+  );
+}
+function createGetCommand(config3) {
+  const cmd = new commander.Command("get").description(`Get a single ${config3.resourceName}`);
+  for (const arg of config3.args) {
+    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
+  }
+  return cmd.action(
+    withErrorHandling(async (...actionArgs) => {
+      const args = actionArgs.slice(0, config3.args.length);
+      const command = actionArgs[actionArgs.length - 1];
+      const { output, client, isJsonOutput } = createCommandContext(command);
+      const label = args.join("/");
+      const item = await config3.get(client, ...args);
+      if (!item) {
+        return output.error(`${capitalize(config3.resourceName)} not found: ${label}`, {
+          suggestion: `Check that the ${config3.args.join(" and ")} ${config3.args.length > 1 ? "are" : "is"} correct`
+        });
+      }
+      if (isJsonOutput) {
+        output.json(item);
+      } else {
+        output.success(`${capitalize(config3.resourceName)}: ${label}`, config3.formatOutput(item));
+      }
+    })
+  );
+}
+function createListCommand(config3) {
+  const cmd = new commander.Command("list").description(`List ${config3.resourceNamePlural}`);
+  for (const arg of config3.args) {
+    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
+  }
+  if (config3.hasPagination) {
+    cmd.option("--limit <n>", "Number of items per page", "20");
+    cmd.option("--page <n>", "Page number", "1");
+  }
+  return cmd.action(
+    withErrorHandling(async (...actionArgs) => {
+      const args = actionArgs.slice(0, config3.args.length);
+      const options = actionArgs[config3.args.length];
+      const command = actionArgs[actionArgs.length - 1];
+      const { output, client, isJsonOutput } = createCommandContext(command);
+      const pagination = config3.hasPagination ? parsePaginationOptions(options) : void 0;
+      const result = await config3.list(client, args, pagination);
+      if (isJsonOutput) {
+        output.json({
+          [config3.resourceNamePlural]: result.items,
+          ...result.pagination && { pagination: result.pagination }
+        });
+      } else if (result.items.length === 0) {
+        const context = args.length > 0 ? ` for ${args.join("/")}` : "";
+        output.info(`No ${config3.resourceNamePlural} found${context}`);
+      } else {
+        output.table(config3.tableHeaders, result.items.map(config3.formatRow));
+        if (result.pagination) {
+          output.info(
+            `Showing ${result.items.length} of ${result.pagination.total} ${config3.resourceNamePlural} (page ${result.pagination.page})`
+          );
+        } else {
+          output.info(`${result.items.length} ${config3.resourceNamePlural}`);
+        }
+      }
+    })
+  );
+}
+
+// src/cli/content/writer.ts
+async function ensureDir(dirPath) {
+  try {
+    await fs3__namespace.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function writeJsonFile(filePath, data) {
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await fs3__namespace.writeFile(filePath, content, "utf-8");
+}
+async function writeEntries(contentDir, pulledEntries) {
+  const entriesDir = path9__namespace.join(contentDir, "entries");
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  await ensureDir(entriesDir);
+  await ensureDir(metaDir);
+  const { contentType, entries, meta } = pulledEntries;
+  const entriesFile = {
+    contentType,
+    entries: entries.map(mapEntryForOutput)
+  };
+  const filePath = path9__namespace.join(entriesDir, `${contentType}.json`);
+  await writeJsonFile(filePath, entriesFile);
+  const metaPath = path9__namespace.join(metaDir, `${contentType}.json`);
+  await writeJsonFile(metaPath, meta);
+  return { filePath, metaPath };
+}
+async function writePages(contentDir, pulledPages) {
+  const pagesDir = path9__namespace.join(contentDir, "pages");
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  await ensureDir(pagesDir);
+  await ensureDir(metaDir);
+  const filePaths = [];
+  const pagesMeta = {};
+  for (const page of pulledPages.pages) {
+    const filePath = path9__namespace.join(pagesDir, `${page.identifier}.json`);
+    await writeJsonFile(filePath, page);
+    filePaths.push(filePath);
+    pagesMeta[page.identifier] = {
+      createdAt: page.createdAt,
+      updatedAt: page.updatedAt
+    };
+  }
+  const metaPath = path9__namespace.join(metaDir, "pages.json");
+  await writeJsonFile(metaPath, {
+    pulledAt: pulledPages.meta.pulledAt,
+    pages: pagesMeta
+  });
+  return { filePaths, metaPath };
+}
+async function writeNavigation(contentDir, pulledNavigation) {
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  await ensureDir(contentDir);
+  await ensureDir(metaDir);
+  const filePath = path9__namespace.join(contentDir, "navigation.json");
+  await writeJsonFile(filePath, {
+    menus: pulledNavigation.menus
+  });
+  const menusMeta = {};
+  for (const menu of pulledNavigation.menus) {
+    menusMeta[menu.name] = {
+      createdAt: menu.createdAt,
+      updatedAt: menu.updatedAt
+    };
+  }
+  const metaPath = path9__namespace.join(metaDir, "navigation.json");
+  await writeJsonFile(metaPath, {
+    pulledAt: pulledNavigation.meta.pulledAt,
+    menus: menusMeta
+  });
+  return { filePath, metaPath };
+}
+async function writeSettings(contentDir, pulledSettings) {
+  await ensureDir(contentDir);
+  const filePath = path9__namespace.join(contentDir, "settings.json");
+  await writeJsonFile(filePath, pulledSettings.settings);
+  return filePath;
+}
+async function fileExists(filePath) {
+  try {
+    await fs3__namespace.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile(filePath) {
+  const content = await fs3__namespace.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function listFiles(dirPath, extension) {
+  try {
+    const files = await fs3__namespace.readdir(dirPath);
+    return files.filter((f) => f.endsWith(extension)).map((f) => path9__namespace.join(dirPath, f));
+  } catch {
+    return [];
+  }
+}
+async function readEntries(contentDir, contentType) {
+  const entriesDir = path9__namespace.join(contentDir, "entries");
+  const result = /* @__PURE__ */ new Map();
+  {
+    const files = await listFiles(entriesDir, ".json");
+    for (const filePath of files) {
+      try {
+        const file = await readJsonFile(filePath);
+        result.set(file.contentType, file.entries);
+      } catch (error) {
+        console.warn(`Warning: Could not parse ${filePath}:`, error);
+      }
+    }
+  }
+  return result;
+}
+async function readPages(contentDir) {
+  const pagesDir = path9__namespace.join(contentDir, "pages");
+  const pages = [];
+  const files = await listFiles(pagesDir, ".json");
+  for (const filePath of files) {
+    try {
+      const page = await readJsonFile(filePath);
+      pages.push(page);
+    } catch (error) {
+      console.warn(`Warning: Could not parse ${filePath}:`, error);
+    }
+  }
+  return pages;
+}
+async function readNavigation(contentDir) {
+  const filePath = path9__namespace.join(contentDir, "navigation.json");
+  if (!await fileExists(filePath)) {
+    return null;
+  }
+  return readJsonFile(filePath);
+}
+async function readSettings(contentDir) {
+  const filePath = path9__namespace.join(contentDir, "settings.json");
+  if (!await fileExists(filePath)) {
+    return null;
+  }
+  return readJsonFile(filePath);
+}
+async function readAllContent(contentDir) {
+  const [entries, pages, navigation, settings] = await Promise.all([
+    readEntries(contentDir),
+    readPages(contentDir),
+    readNavigation(contentDir),
+    readSettings(contentDir)
+  ]);
+  return { entries, pages, navigation, settings };
+}
+async function contentDirExists(contentDir) {
+  return fileExists(contentDir);
+}
+async function getContentSummary(contentDir) {
+  const content = await readAllContent(contentDir);
+  const entryTypes = Array.from(content.entries.keys());
+  let totalEntries = 0;
+  for (const entries of content.entries.values()) {
+    totalEntries += entries.length;
+  }
+  return {
+    hasEntries: content.entries.size > 0,
+    entryTypes,
+    totalEntries,
+    hasPages: content.pages.length > 0,
+    pageCount: content.pages.length,
+    hasNavigation: content.navigation !== null && content.navigation.menus.length > 0,
+    menuCount: content.navigation?.menus.length ?? 0,
+    hasSettings: content.settings !== null
+  };
+}
+async function readEntriesMeta(contentDir, contentType) {
+  const metaPath = path9__namespace.join(contentDir, ".meta", `${contentType}.json`);
+  try {
+    const content = await fs3__namespace.readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function readAllMeta(contentDir) {
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  const metaMap = /* @__PURE__ */ new Map();
+  try {
+    const files = await fs3__namespace.readdir(metaDir);
+    for (const file of files) {
+      if (file.endsWith(".json") && file !== "pages.json" && file !== "navigation.json") {
+        const contentType = file.replace(".json", "");
+        const meta = await readEntriesMeta(contentDir, contentType);
+        if (meta) metaMap.set(contentType, meta);
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return metaMap;
+}
+async function readPagesMeta(contentDir) {
+  const metaPath = path9__namespace.join(contentDir, ".meta", "pages.json");
+  try {
+    const content = await fs3__namespace.readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function readNavigationMeta(contentDir) {
+  const metaPath = path9__namespace.join(contentDir, ".meta", "navigation.json");
+  try {
+    const content = await fs3__namespace.readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/cli/commands/pull.ts
+var DEFAULT_PAGE_LIMIT = 500;
+async function pullEntriesWithPagination(client, contentType, output) {
+  const allEntries = [];
+  const aggregatedMeta = {};
+  let page = 1;
+  let hasMore = true;
+  let pulledAt = (/* @__PURE__ */ new Date()).toISOString();
+  while (hasMore) {
+    const result = await client.pull.entries(contentType, {
+      page,
+      limit: DEFAULT_PAGE_LIMIT
+    });
+    allEntries.push(...result.entries);
+    if (result.meta.entries) {
+      Object.assign(aggregatedMeta, result.meta.entries);
+    }
+    pulledAt = result.meta.pulledAt;
+    hasMore = result.pagination.hasMore;
+    if (hasMore) {
+      output.info(`Fetched ${allEntries.length} entries (page ${page})...`);
+    }
+    page++;
+  }
+  return {
+    contentType,
+    entries: allEntries,
+    meta: { pulledAt, entries: aggregatedMeta },
+    pagination: {
+      page: 1,
+      limit: allEntries.length,
+      total: allEntries.length,
+      hasMore: false
+    }
+  };
+}
+async function writeAllEntries(contentDir, entriesByType, pulledAt, entriesMeta) {
+  let totalCount = 0;
+  const files = [];
+  for (const [contentType, entries] of Object.entries(entriesByType)) {
+    const ctMeta = {};
+    for (const entry of entries) {
+      const key = `${contentType}:${entry.identifier}`;
+      if (entriesMeta?.[key]) {
+        ctMeta[entry.identifier] = entriesMeta[key];
+      }
+    }
+    const { filePath } = await writeEntries(contentDir, {
+      contentType,
+      entries,
+      meta: { pulledAt, entries: ctMeta },
+      pagination: { limit: entries.length, total: entries.length}
+    });
+    totalCount += entries.length;
+    files.push(filePath);
+  }
+  return { totalCount, files };
+}
+async function fetchAllContentPaginated(client, contentTypes, output) {
+  const allEntries = {};
+  const allMeta = {};
+  for (const contentType of contentTypes) {
+    output.info(`Fetching ${contentType} entries...`);
+    const result = await pullEntriesWithPagination(client, contentType, output);
+    allEntries[contentType] = result.entries.map(mapEntryForOutput);
+    for (const [id, meta] of Object.entries(result.meta.entries || {})) {
+      allMeta[`${contentType}:${id}`] = meta;
+    }
+    output.info(`  ${result.entries.length} entries`);
+  }
+  output.info("Fetching pages...");
+  const pagesResult = await client.pull.pages();
+  output.info("Fetching navigation...");
+  const navigationResult = await client.pull.navigation();
+  output.info("Fetching settings...");
+  const settingsResult = await client.pull.settings();
+  return {
+    entries: allEntries,
+    pages: pagesResult.pages,
+    navigation: navigationResult.menus,
+    settings: settingsResult.settings,
+    meta: { pulledAt: (/* @__PURE__ */ new Date()).toISOString(), entries: allMeta }
+  };
+}
+var pullCommand = new commander.Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").addHelpText("after", `
+Examples:
+  $ riverbankcms pull                         # Pull all content
+  $ riverbankcms pull --remote                # Pull from production
+  $ riverbankcms pull entries                 # Pull all entries
+  $ riverbankcms pull entries blog-post       # Pull specific content type
+  $ riverbankcms pull pages                   # Pull pages with blocks
+  $ riverbankcms pull navigation              # Pull navigation menus
+  $ riverbankcms pull settings                # Pull site settings
+  $ riverbankcms pull --output ./src/content  # Custom output directory
+`).action(
+  withErrorHandling(
+    async (scope, type, options, command) => {
+      const { output, client } = createCommandContext(command);
+      const contentDir = path9__namespace.resolve(options.output ?? "./content");
+      if (await contentDirExists(contentDir) && !options.force && !options.yes) {
+        if (!process.stdin.isTTY) {
+          output.error("Content directory already exists and --yes not specified", {
+            suggestion: "Use --yes or --force to overwrite in non-interactive mode"
+          });
+          return;
+        }
+        const response = await prompts__default.default({
+          type: "confirm",
+          name: "overwrite",
+          message: `Content directory '${path9__namespace.basename(contentDir)}' already exists. Overwrite?`,
+          initial: false
+        });
+        if (!response.overwrite) {
+          output.info("Aborted.");
+          return;
+        }
+      }
+      const pullScope = scope?.toLowerCase() ?? "all";
+      switch (pullScope) {
+        case "entries": {
+          if (type) {
+            output.info(`Pulling entries for content type: ${type}`);
+            const result = await pullEntriesWithPagination(client, type, output);
+            const { filePath, metaPath } = await writeEntries(contentDir, result);
+            output.success(`Pulled ${result.entries.length} entries`, {
+              contentType: type,
+              file: filePath,
+              meta: metaPath
+            });
+          } else {
+            output.info("Pulling all entries");
+            let result = await client.pull.all();
+            if (result.meta.truncated) {
+              output.warn("Content was truncated due to size limits.");
+              output.info("Fetching complete data via pagination...");
+              const contentTypes = Object.keys(result.entries);
+              result = await fetchAllContentPaginated(client, contentTypes, output);
+            }
+            const { totalCount, files } = await writeAllEntries(
+              contentDir,
+              result.entries,
+              result.meta.pulledAt,
+              result.meta.entries
+            );
+            output.success(`Pulled ${totalCount} entries across ${Object.keys(result.entries).length} content types`, {
+              files
+            });
+          }
+          break;
+        }
+        case "pages": {
+          output.info("Pulling pages");
+          const result = await client.pull.pages();
+          const { filePaths, metaPath } = await writePages(contentDir, result);
+          output.success(`Pulled ${result.pages.length} pages`, { files: filePaths, meta: metaPath });
+          break;
+        }
+        case "navigation": {
+          output.info("Pulling navigation menus");
+          const result = await client.pull.navigation();
+          const { filePath, metaPath } = await writeNavigation(contentDir, result);
+          output.success(`Pulled ${result.menus.length} navigation menus`, { file: filePath, meta: metaPath });
+          break;
+        }
+        case "settings": {
+          output.info("Pulling site settings");
+          const result = await client.pull.settings();
+          const filePath = await writeSettings(contentDir, result);
+          output.success("Pulled site settings", { file: filePath });
+          break;
+        }
+        case "all":
+        default: {
+          output.info("Pulling all content");
+          let result = await client.pull.all();
+          if (result.meta.truncated) {
+            output.warn("Content was truncated due to size limits.");
+            output.info("Fetching complete data via pagination...");
+            const contentTypes = Object.keys(result.entries);
+            result = await fetchAllContentPaginated(client, contentTypes, output);
+          }
+          const { totalCount: totalEntries } = await writeAllEntries(
+            contentDir,
+            result.entries,
+            result.meta.pulledAt,
+            result.meta.entries
+          );
+          await writePages(contentDir, { pages: result.pages, meta: result.meta });
+          await writeNavigation(contentDir, { menus: result.navigation, meta: result.meta });
+          await writeSettings(contentDir, { settings: result.settings, meta: result.meta });
+          output.success("Pull complete", {
+            entries: { count: totalEntries, types: Object.keys(result.entries).length },
+            pages: { count: result.pages.length },
+            navigation: { count: result.navigation.length },
+            directory: contentDir
+          });
+          break;
+        }
+      }
+    }
+  )
+);
+
+// src/cli/config-loader.ts
+init_load_config();
+var DEFAULT_SYNC_CONFIG = {
+  existingEntries: "skip",
+  contentTarget: "draft"
+};
+async function loadCliConfig(configPath) {
+  try {
+    const rawConfig = await loadConfigFile(configPath);
+    const configObj = rawConfig;
+    const contentDir = typeof configObj.contentDir === "string" ? configObj.contentDir : "./content";
+    const syncConfig = configObj.sync;
+    return {
+      contentDir,
+      sync: {
+        existingEntries: syncConfig?.existingEntries ?? DEFAULT_SYNC_CONFIG.existingEntries,
+        contentTarget: syncConfig?.contentTarget ?? DEFAULT_SYNC_CONFIG.contentTarget
+      }
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Config file not found")) {
+      return {
+        contentDir: "./content",
+        sync: { ...DEFAULT_SYNC_CONFIG }
+      };
+    }
+    throw error;
+  }
+}
+
+// src/cli/sync/mapper.ts
+function stripNavigationItemIds(items) {
+  return items.map((item) => {
+    const result = {
+      label: item.label,
+      url: item.url
+    };
+    if (item.children && item.children.length > 0) {
+      result.children = stripNavigationItemIds(item.children);
+    }
+    return result;
+  });
+}
+
+// src/cli/sync/diff.ts
+function findChangedFields(local, remote, prefix = "") {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(remote)]);
+  for (const key of allKeys) {
+    const path11 = prefix ? `${prefix}.${key}` : key;
+    const localVal = local[key];
+    const remoteVal = remote[key];
+    if (!equal__default.default(localVal, remoteVal)) {
+      changes.push(path11);
+    }
+  }
+  return changes;
+}
+function buildJsonDiff(diff, local, remote, mode) {
+  const summary = { creates: 0, updates: 0, deletes: 0 };
+  const changes = [];
+  const localPages = new Map(local.pages.map((page) => [page.identifier, page]));
+  const remotePages = new Map(remote.pages.map((page) => [page.identifier, page]));
+  const localEntries = local.entries;
+  const remoteEntries = remote.entries;
+  const localMenus = new Map((local.navigation?.menus ?? []).map((menu) => [menu.name, menu]));
+  const remoteMenus = new Map(remote.navigation.map((menu) => [menu.name, menu]));
+  const addChange = (change) => {
+    if (change.operation === "create") summary.creates += 1;
+    if (change.operation === "update") summary.updates += 1;
+    if (change.operation === "delete") summary.deletes += 1;
+    changes.push(change);
+  };
+  for (const [contentType, entryDiffs] of diff.entries) {
+    for (const entryDiff of entryDiffs) {
+      if (entryDiff.type === "unchanged") continue;
+      if (entryDiff.type !== "create" && entryDiff.type !== "update") continue;
+      const identifier = `${contentType}/${entryDiff.identifier}`;
+      const localEntry = localEntries.get(contentType)?.find((entry) => entry.identifier === entryDiff.identifier);
+      const remoteEntry = remoteEntries[contentType]?.find((entry) => entry.identifier === entryDiff.identifier);
+      const change = {
+        type: "entry",
+        identifier,
+        operation: entryDiff.type
+      };
+      if (mode === "full") {
+        change.before = remoteEntry ?? null;
+        change.after = localEntry ?? null;
+        if (entryDiff.changes) change.diff = { changes: entryDiff.changes };
+      }
+      addChange(change);
+    }
+  }
+  for (const pageDiff of diff.pages) {
+    if (pageDiff.type === "unchanged") continue;
+    if (pageDiff.type !== "create" && pageDiff.type !== "update") continue;
+    const identifier = pageDiff.identifier;
+    const localPage = localPages.get(identifier);
+    const remotePage = remotePages.get(identifier);
+    const change = {
+      type: "page",
+      identifier,
+      operation: pageDiff.type
+    };
+    if (mode === "full") {
+      change.before = remotePage ?? null;
+      change.after = localPage ?? null;
+      if (pageDiff.changes) change.diff = { changes: pageDiff.changes };
+    }
+    addChange(change);
+    if (pageDiff.blocks) {
+      for (const blockDiff of pageDiff.blocks) {
+        if (blockDiff.type === "unchanged") continue;
+        const pageId = blockDiff.pageIdentifier;
+        const localBlock = localPages.get(pageId)?.blocks?.find((block) => block.identifier === blockDiff.identifier);
+        const remoteBlock = remotePages.get(pageId)?.blocks?.find((block) => block.identifier === blockDiff.identifier);
+        if (blockDiff.type === "reorder") {
+          const localOrder = localPages.get(pageId)?.blocks?.map((block) => block.identifier) ?? [];
+          addChange({
+            type: "block",
+            identifier: `${pageId}::reorder`,
+            operation: "update",
+            ...mode === "full" ? { diff: { reorder: true, order: localOrder } } : {}
+          });
+          continue;
+        }
+        const operation = blockDiff.type === "delete" ? "delete" : blockDiff.type;
+        const identifier2 = `${pageId}/${blockDiff.identifier}`;
+        const change2 = {
+          type: "block",
+          identifier: identifier2,
+          operation
+        };
+        if (mode === "full") {
+          change2.before = remoteBlock ?? null;
+          change2.after = localBlock ?? null;
+          if (blockDiff.changes) change2.diff = { changes: blockDiff.changes };
+        }
+        addChange(change2);
+      }
+    }
+  }
+  for (const navDiff of diff.navigation) {
+    if (navDiff.type === "unchanged") continue;
+    if (navDiff.type !== "create" && navDiff.type !== "update") continue;
+    const identifier = navDiff.name;
+    const localMenu = localMenus.get(navDiff.name);
+    const remoteMenu = remoteMenus.get(navDiff.name);
+    const change = {
+      type: "navigation",
+      identifier,
+      operation: navDiff.type
+    };
+    if (mode === "full") {
+      change.before = remoteMenu ? { ...remoteMenu, items: stripNavigationItemIds(remoteMenu.items) } : null;
+      change.after = localMenu ?? null;
+      if (navDiff.changes) change.diff = { changes: navDiff.changes };
+    }
+    addChange(change);
+  }
+  if (diff.settings) {
+    const change = {
+      type: "settings",
+      identifier: "settings",
+      operation: "update"
+    };
+    if (mode === "full") {
+      change.before = remote.settings ?? null;
+      change.after = local.settings ?? null;
+      if (diff.settings.changes) change.diff = { changes: diff.settings.changes };
+    }
+    addChange(change);
+  }
+  return { summary, changes };
+}
+function calculateEntryDiffs(localEntries, remoteEntries, options) {
+  const diffs = /* @__PURE__ */ new Map();
+  const summary = { create: 0, update: 0, unchanged: 0 };
+  const remoteLookup = /* @__PURE__ */ new Map();
+  for (const [contentType, entries] of Object.entries(remoteEntries)) {
+    const typeMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      typeMap.set(entry.identifier, entry.data);
+    }
+    remoteLookup.set(contentType, typeMap);
+  }
+  for (const [contentType, localList] of localEntries) {
+    const typeDiffs = [];
+    const remoteTypeMap = remoteLookup.get(contentType) ?? /* @__PURE__ */ new Map();
+    for (const localEntry of localList) {
+      const remoteData = remoteTypeMap.get(localEntry.identifier);
+      if (!remoteData) {
+        typeDiffs.push({
+          type: "create",
+          identifier: localEntry.identifier,
+          contentType
+        });
+        summary.create++;
+      } else if (options.existingEntries === "skip") {
+        typeDiffs.push({
+          type: "unchanged",
+          identifier: localEntry.identifier,
+          contentType
+        });
+        summary.unchanged++;
+      } else if (!equal__default.default(localEntry.data, remoteData)) {
+        const changes = findChangedFields(
+          localEntry.data,
+          remoteData
+        );
+        typeDiffs.push({
+          type: "update",
+          identifier: localEntry.identifier,
+          contentType,
+          changes
+        });
+        summary.update++;
+      } else {
+        typeDiffs.push({
+          type: "unchanged",
+          identifier: localEntry.identifier,
+          contentType
+        });
+        summary.unchanged++;
+      }
+    }
+    if (typeDiffs.length > 0) {
+      diffs.set(contentType, typeDiffs);
+    }
+  }
+  return { diffs, summary };
+}
+function calculatePageDiffs(localPages, remotePages, options) {
+  const diffs = [];
+  const summary = { create: 0, update: 0, unchanged: 0 };
+  const blockSummary = { create: 0, update: 0, delete: 0, unchanged: 0 };
+  const remoteLookup = /* @__PURE__ */ new Map();
+  for (const page of remotePages) {
+    remoteLookup.set(page.identifier, page);
+  }
+  for (const localPage of localPages) {
+    const remotePage = remoteLookup.get(localPage.identifier);
+    if (!remotePage) {
+      const blockDiffs = (localPage.blocks ?? []).map((block) => {
+        blockSummary.create++;
+        return {
+          type: "create",
+          identifier: block.identifier,
+          pageIdentifier: localPage.identifier
+        };
+      });
+      diffs.push({
+        type: "create",
+        identifier: localPage.identifier,
+        blocks: blockDiffs
+      });
+      summary.create++;
+    } else if (options.existingEntries === "skip") {
+      diffs.push({
+        type: "unchanged",
+        identifier: localPage.identifier
+      });
+      summary.unchanged++;
+    } else {
+      const pageChanged = localPage.title !== remotePage.title || localPage.path !== remotePage.path;
+      const blockDiffs = calculateBlockDiffs(
+        localPage.blocks ?? [],
+        remotePage.blocks ?? [],
+        localPage.identifier,
+        blockSummary
+      );
+      if (pageChanged || blockDiffs.some((b) => b.type !== "unchanged")) {
+        const changes = [];
+        if (localPage.title !== remotePage.title) changes.push("title");
+        if (localPage.path !== remotePage.path) changes.push("path");
+        diffs.push({
+          type: "update",
+          identifier: localPage.identifier,
+          changes: changes.length > 0 ? changes : void 0,
+          blocks: blockDiffs
+        });
+        summary.update++;
+      } else {
+        diffs.push({
+          type: "unchanged",
+          identifier: localPage.identifier
+        });
+        summary.unchanged++;
+      }
+    }
+  }
+  return { diffs, summary, blockSummary };
+}
+function calculateBlockDiffs(localBlocks, remoteBlocks, pageIdentifier, summary) {
+  const diffs = [];
+  const remoteLookup = /* @__PURE__ */ new Map();
+  for (const block of remoteBlocks) {
+    remoteLookup.set(block.identifier, block);
+  }
+  const seenRemoteIds = /* @__PURE__ */ new Set();
+  for (const localBlock of localBlocks) {
+    const remoteBlock = remoteLookup.get(localBlock.identifier);
+    seenRemoteIds.add(localBlock.identifier);
+    if (!remoteBlock) {
+      diffs.push({
+        type: "create",
+        identifier: localBlock.identifier,
+        pageIdentifier
+      });
+      summary.create++;
+    } else if (!equal__default.default(localBlock.data, remoteBlock.data) || localBlock.kind !== remoteBlock.kind) {
+      const changes = findChangedFields(
+        localBlock.data,
+        remoteBlock.data
+      );
+      if (localBlock.kind !== remoteBlock.kind) {
+        changes.push("kind");
+      }
+      diffs.push({
+        type: "update",
+        identifier: localBlock.identifier,
+        pageIdentifier,
+        changes
+      });
+      summary.update++;
+    } else {
+      diffs.push({
+        type: "unchanged",
+        identifier: localBlock.identifier,
+        pageIdentifier
+      });
+      summary.unchanged++;
+    }
+  }
+  for (const remoteBlock of remoteBlocks) {
+    if (!seenRemoteIds.has(remoteBlock.identifier)) {
+      diffs.push({
+        type: "delete",
+        identifier: remoteBlock.identifier,
+        pageIdentifier
+      });
+      summary.delete++;
+    }
+  }
+  const localOrder = localBlocks.filter((b) => remoteLookup.has(b.identifier)).map((b) => b.identifier);
+  const remoteOrder = remoteBlocks.filter((b) => seenRemoteIds.has(b.identifier)).sort((a, b) => a.position - b.position).map((b) => b.identifier);
+  if (localOrder.length > 1 && !equal__default.default(localOrder, remoteOrder)) {
+    diffs.push({
+      type: "reorder",
+      identifier: pageIdentifier,
+      pageIdentifier
+    });
+  }
+  return diffs;
+}
+function calculateNavigationDiffs(localNavigation, remoteNavigation) {
+  const diffs = [];
+  const summary = { create: 0, update: 0, unchanged: 0 };
+  if (!localNavigation || !localNavigation.menus) {
+    return { diffs, summary };
+  }
+  const remoteLookup = /* @__PURE__ */ new Map();
+  for (const menu of remoteNavigation) {
+    remoteLookup.set(menu.name, menu);
+  }
+  for (const localMenu of localNavigation.menus) {
+    const remoteMenu = remoteLookup.get(localMenu.name);
+    if (!remoteMenu) {
+      diffs.push({
+        type: "create",
+        name: localMenu.name
+      });
+      summary.create++;
+    } else if (!equal__default.default(localMenu.items, stripNavigationItemIds(remoteMenu.items))) {
+      diffs.push({
+        type: "update",
+        name: localMenu.name,
+        changes: ["items"]
+      });
+      summary.update++;
+    } else {
+      diffs.push({
+        type: "unchanged",
+        name: localMenu.name
+      });
+      summary.unchanged++;
+    }
+  }
+  return { diffs, summary };
+}
+function calculateSettingsDiff(localSettings, remoteSettings) {
+  const summary = { update: 0, unchanged: 0 };
+  if (!localSettings) {
+    return { diff: null, summary };
+  }
+  const changes = [];
+  if (localSettings.homepageId !== remoteSettings.homepageId) {
+    changes.push("homepageId");
+  }
+  if (!equal__default.default(localSettings.seoDefaults, remoteSettings.seoDefaults)) {
+    changes.push("seoDefaults");
+  }
+  if (changes.length > 0) {
+    summary.update = 1;
+    return {
+      diff: { type: "update", changes },
+      summary
+    };
+  }
+  summary.unchanged = 1;
+  return { diff: null, summary };
+}
+function calculateDiff(local, remote, options) {
+  const { diffs: entryDiffs, summary: entrySummary } = calculateEntryDiffs(
+    local.entries,
+    remote.entries,
+    options
+  );
+  const { diffs: pageDiffs, summary: pageSummary, blockSummary } = calculatePageDiffs(
+    local.pages,
+    remote.pages,
+    options
+  );
+  const { diffs: navDiffs, summary: navSummary } = calculateNavigationDiffs(
+    local.navigation,
+    remote.navigation
+  );
+  const { diff: settingsDiff, summary: settingsSummary } = calculateSettingsDiff(
+    local.settings,
+    remote.settings
+  );
+  return {
+    entries: entryDiffs,
+    pages: pageDiffs,
+    navigation: navDiffs,
+    settings: settingsDiff,
+    summary: {
+      entries: entrySummary,
+      pages: pageSummary,
+      blocks: blockSummary,
+      navigation: navSummary,
+      settings: settingsSummary
+    }
+  };
+}
+function hasPendingChanges(diff) {
+  const { summary } = diff;
+  return summary.entries.create > 0 || summary.entries.update > 0 || summary.pages.create > 0 || summary.pages.update > 0 || summary.blocks.create > 0 || summary.blocks.update > 0 || summary.blocks.delete > 0 || summary.navigation.create > 0 || summary.navigation.update > 0 || summary.settings.update > 0;
+}
+function formatDiffSummary(diff) {
+  const lines = [];
+  const { summary } = diff;
+  if (summary.entries.create > 0 || summary.entries.update > 0) {
+    lines.push(`Entries: +${summary.entries.create} ~${summary.entries.update}`);
+  }
+  if (summary.pages.create > 0 || summary.pages.update > 0) {
+    lines.push(`Pages: +${summary.pages.create} ~${summary.pages.update}`);
+  }
+  if (summary.blocks.create > 0 || summary.blocks.update > 0 || summary.blocks.delete > 0) {
+    lines.push(`Blocks: +${summary.blocks.create} ~${summary.blocks.update} -${summary.blocks.delete}`);
+  }
+  if (summary.navigation.create > 0 || summary.navigation.update > 0) {
+    lines.push(`Navigation: +${summary.navigation.create} ~${summary.navigation.update}`);
+  }
+  if (summary.settings.update > 0) {
+    lines.push(`Settings: ~${summary.settings.update}`);
+  }
+  if (lines.length === 0) {
+    return "No changes detected";
+  }
+  return lines.join("\n");
+}
+function formatDiffDetail(diff) {
+  const lines = [];
+  for (const [contentType, entryDiffs] of diff.entries) {
+    const creates = entryDiffs.filter((d) => d.type === "create");
+    const updates = entryDiffs.filter((d) => d.type === "update");
+    if (creates.length > 0) {
+      lines.push(`
+${contentType} (new):`);
+      for (const d of creates) {
+        lines.push(`  + ${d.identifier}`);
+      }
+    }
+    if (updates.length > 0) {
+      lines.push(`
+${contentType} (updated):`);
+      for (const d of updates) {
+        lines.push(`  ~ ${d.identifier}${d.changes ? ` [${d.changes.join(", ")}]` : ""}`);
+      }
+    }
+  }
+  const pageCreates = diff.pages.filter((d) => d.type === "create");
+  const pageUpdates = diff.pages.filter((d) => d.type === "update");
+  if (pageCreates.length > 0) {
+    lines.push("\nPages (new):");
+    for (const d of pageCreates) {
+      lines.push(`  + ${d.identifier}`);
+    }
+  }
+  if (pageUpdates.length > 0) {
+    lines.push("\nPages (updated):");
+    for (const d of pageUpdates) {
+      lines.push(`  ~ ${d.identifier}${d.changes ? ` [${d.changes.join(", ")}]` : ""}`);
+    }
+  }
+  const navCreates = diff.navigation.filter((d) => d.type === "create");
+  const navUpdates = diff.navigation.filter((d) => d.type === "update");
+  if (navCreates.length > 0) {
+    lines.push("\nNavigation (new):");
+    for (const d of navCreates) {
+      lines.push(`  + ${d.name}`);
+    }
+  }
+  if (navUpdates.length > 0) {
+    lines.push("\nNavigation (updated):");
+    for (const d of navUpdates) {
+      lines.push(`  ~ ${d.name}`);
+    }
+  }
+  if (diff.settings) {
+    lines.push("\nSettings (updated):");
+    lines.push(`  ~ [${diff.settings.changes.join(", ")}]`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/sync/executor.ts
+function createEmptyResult() {
+  return {
+    entries: { created: 0, updated: 0, failed: 0 },
+    pages: { created: 0, updated: 0, failed: 0 },
+    blocks: { created: 0, updated: 0, deleted: 0, failed: 0 },
+    navigation: { created: 0, updated: 0, failed: 0 },
+    settings: { updated: 0, failed: 0 },
+    errors: []
+  };
+}
+async function syncEntries(client, diff, local, options, result) {
+  for (const [contentType, entryDiffs] of diff.entries) {
+    const localEntries = local.entries.get(contentType) ?? [];
+    const entryLookup = new Map(localEntries.map((e) => [e.identifier, e]));
+    for (const entryDiff of entryDiffs) {
+      if (entryDiff.type === "unchanged") continue;
+      const localEntry = entryLookup.get(entryDiff.identifier);
+      if (!localEntry) continue;
+      try {
+        if (options.dryRun) ;
+        await client.entries.upsert({
+          contentType,
+          identifier: localEntry.identifier,
+          data: localEntry.data,
+          slug: localEntry.slug
+        });
+        if (options.contentTarget === "publish") {
+          await client.entries.publish(contentType, localEntry.identifier);
+        }
+        if (entryDiff.type === "create") {
+          result.entries.created++;
+        } else {
+          result.entries.updated++;
+        }
+      } catch (error) {
+        result.entries.failed++;
+        result.errors.push({
+          resource: "entry",
+          identifier: `${contentType}/${entryDiff.identifier}`,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+}
+async function syncPages(client, diff, local, options, result) {
+  const pageLookup = new Map(local.pages.map((p) => [p.identifier, p]));
+  for (const pageDiff of diff.pages) {
+    if (pageDiff.type === "unchanged") continue;
+    const localPage = pageLookup.get(pageDiff.identifier);
+    if (!localPage) continue;
+    try {
+      if (options.dryRun) ;
+      await client.pages.upsert({
+        identifier: localPage.identifier,
+        title: localPage.title,
+        path: localPage.path,
+        seoTitle: localPage.seoTitle,
+        seoDescription: localPage.seoDescription
+      });
+      if (pageDiff.blocks && localPage.blocks) {
+        await syncBlocks(
+          client,
+          pageDiff.identifier,
+          pageDiff.blocks,
+          localPage.blocks,
+          options,
+          result
+        );
+      }
+      if (options.contentTarget === "publish") {
+        await client.pages.publish(localPage.identifier);
+      }
+      if (pageDiff.type === "create") {
+        result.pages.created++;
+      } else {
+        result.pages.updated++;
+      }
+    } catch (error) {
+      result.pages.failed++;
+      result.errors.push({
+        resource: "page",
+        identifier: pageDiff.identifier,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+async function syncBlocks(client, pageIdentifier, blockDiffs, localBlocks, options, result) {
+  const blockLookup = new Map(localBlocks.map((b) => [b.identifier, b]));
+  for (const blockDiff of blockDiffs) {
+    if (blockDiff.type === "unchanged") continue;
+    try {
+      if (blockDiff.type === "delete") {
+        await client.blocks.delete(pageIdentifier, blockDiff.identifier);
+        result.blocks.deleted++;
+      } else {
+        const localBlock = blockLookup.get(blockDiff.identifier);
+        if (!localBlock) continue;
+        await client.blocks.upsert(pageIdentifier, {
+          identifier: localBlock.identifier,
+          kind: localBlock.kind,
+          data: localBlock.data
+        });
+        if (blockDiff.type === "create") {
+          result.blocks.created++;
+        } else {
+          result.blocks.updated++;
+        }
+      }
+    } catch (error) {
+      result.blocks.failed++;
+      result.errors.push({
+        resource: "block",
+        identifier: `${pageIdentifier}/${blockDiff.identifier}`,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const hasReorderDiff = blockDiffs.some((d) => d.type === "reorder");
+  if (hasReorderDiff) {
+    const localIdentifiers = localBlocks.map((b) => b.identifier);
+    if (localIdentifiers.length > 1) {
+      try {
+        await client.blocks.reorder(pageIdentifier, localIdentifiers);
+      } catch {
+      }
+    }
+  }
+}
+async function syncNavigation(client, diff, local, options, result) {
+  if (!local.navigation?.menus) return;
+  const menuLookup = new Map(local.navigation.menus.map((m) => [m.name, m]));
+  for (const navDiff of diff.navigation) {
+    if (navDiff.type === "unchanged") continue;
+    const localMenu = menuLookup.get(navDiff.name);
+    if (!localMenu) continue;
+    try {
+      if (options.dryRun) ;
+      await client.navigation.upsert({
+        name: localMenu.name,
+        items: localMenu.items
+      });
+      if (navDiff.type === "create") {
+        result.navigation.created++;
+      } else {
+        result.navigation.updated++;
+      }
+    } catch (error) {
+      result.navigation.failed++;
+      result.errors.push({
+        resource: "navigation",
+        identifier: navDiff.name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+async function syncSettings(client, diff, local, options, result) {
+  if (!diff.settings || !local.settings) return;
+  try {
+    if (options.dryRun) ;
+    await client.settings.update({
+      homepageId: local.settings.homepageId,
+      seoDefaults: local.settings.seoDefaults
+    });
+    result.settings.updated++;
+  } catch (error) {
+    result.settings.failed++;
+    result.errors.push({
+      resource: "settings",
+      identifier: "site",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function executeSyncPlan(client, diff, local, options, output) {
+  const result = createEmptyResult();
+  const totalOps = diff.summary.entries.create + diff.summary.entries.update + diff.summary.pages.create + diff.summary.pages.update + diff.summary.blocks.create + diff.summary.blocks.update + diff.summary.blocks.delete + diff.summary.navigation.create + diff.summary.navigation.update + diff.summary.settings.update;
+  if (totalOps === 0) {
+    output.info("No changes to sync");
+    return result;
+  }
+  const prefix = "Syncing";
+  output.info(`${prefix} ${totalOps} operations...`);
+  await syncEntries(client, diff, local, options, result);
+  await syncPages(client, diff, local, options, result);
+  await syncNavigation(client, diff, local, options, result);
+  await syncSettings(client, diff, local, options, result);
+  return result;
+}
+function formatSyncResult(result, dryRun) {
+  const lines = [];
+  const verb = "";
+  if (result.entries.created > 0 || result.entries.updated > 0) {
+    lines.push(
+      `Entries: ${verb} created ${result.entries.created}, updated ${result.entries.updated}` + (result.entries.failed > 0 ? `, failed ${result.entries.failed}` : "")
+    );
+  }
+  if (result.pages.created > 0 || result.pages.updated > 0) {
+    lines.push(
+      `Pages: ${verb} created ${result.pages.created}, updated ${result.pages.updated}` + (result.pages.failed > 0 ? `, failed ${result.pages.failed}` : "")
+    );
+  }
+  if (result.blocks.created > 0 || result.blocks.updated > 0 || result.blocks.deleted > 0) {
+    lines.push(
+      `Blocks: ${verb} created ${result.blocks.created}, updated ${result.blocks.updated}, deleted ${result.blocks.deleted}` + (result.blocks.failed > 0 ? `, failed ${result.blocks.failed}` : "")
+    );
+  }
+  if (result.navigation.created > 0 || result.navigation.updated > 0) {
+    lines.push(
+      `Navigation: ${verb} created ${result.navigation.created}, updated ${result.navigation.updated}` + (result.navigation.failed > 0 ? `, failed ${result.navigation.failed}` : "")
+    );
+  }
+  if (result.settings.updated > 0) {
+    lines.push(
+      `Settings: ${verb} updated ${result.settings.updated}` + (result.settings.failed > 0 ? `, failed ${result.settings.failed}` : "")
+    );
+  }
+  if (result.errors.length > 0) {
+    lines.push("\nErrors:");
+    for (const error of result.errors) {
+      lines.push(`  ${error.resource}/${error.identifier}: ${error.error}`);
+    }
+  }
+  if (lines.length === 0) {
+    return "Everything is in sync - no changes needed";
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/push.ts
+function filterLocalContent(localContent, scope, contentType) {
+  if (scope === "entries") {
+    if (contentType) {
+      const filtered = /* @__PURE__ */ new Map();
+      const entries = localContent.entries.get(contentType);
+      if (entries) {
+        filtered.set(contentType, entries);
+      }
+      return { ...localContent, entries: filtered, pages: [], navigation: null };
+    }
+    return { ...localContent, pages: [], navigation: null };
+  }
+  if (scope === "pages") {
+    return { ...localContent, entries: /* @__PURE__ */ new Map(), navigation: null };
+  }
+  if (scope === "navigation") {
+    return { ...localContent, entries: /* @__PURE__ */ new Map(), pages: [] };
+  }
+  return localContent;
+}
+function displayDiff(output, diff, config3, dryRun, isRemote, jsonOutput, jsonDiffMode, localContent, remoteContent) {
+  const envLabel = isRemote ? "REMOTE" : "LOCAL";
+  if (jsonDiffMode) {
+    const jsonDiff = buildJsonDiff(diff, localContent, remoteContent, jsonDiffMode);
+    output.json(jsonDiff);
+    return;
+  }
+  if (jsonOutput) {
+    output.json({
+      summary: diff.summary,
+      syncConfig: config3.sync,
+      dryRun
+    });
+  } else {
+    if (dryRun) {
+      output.info(`[DRY RUN] Changes that would be pushed to ${envLabel}:`);
+    } else {
+      output.info(`Changes to push to ${envLabel}:`);
+    }
+    output.info(formatDiffSummary(diff));
+    output.info(formatDiffDetail(diff));
+  }
+}
+function reportSyncResults(output, result, hasErrors) {
+  if (hasErrors) {
+    output.warn("Push completed with errors");
+  } else {
+    output.success("Push complete");
+  }
+  output.info(formatSyncResult(result));
+}
+function checkForStaleContent(localContent, localMeta, pagesMeta, navigationMeta, remoteContent) {
+  const staleItems = [];
+  for (const [contentType, localEntries] of localContent.entries) {
+    const meta = localMeta.get(contentType);
+    if (!meta) continue;
+    remoteContent.entries[contentType]?.forEach((remoteEntry) => {
+      const localEntry = localEntries.find((e) => e.identifier === remoteEntry.identifier);
+      if (localEntry) {
+        const entryMeta = meta.entries[remoteEntry.identifier];
+        const localBaseTime = entryMeta?.updatedAt;
+        const remoteTime = remoteContent.meta.entries?.[`${contentType}:${remoteEntry.identifier}`]?.updatedAt;
+        if (localBaseTime && remoteTime && new Date(remoteTime) > new Date(localBaseTime)) {
+          staleItems.push(`Entry: ${contentType}/${remoteEntry.identifier} (Remote updated: ${remoteTime})`);
+        }
+      }
+    });
+  }
+  if (pagesMeta) {
+    localContent.pages.forEach((localPage) => {
+      const remotePage = remoteContent.pages.find((p) => p.identifier === localPage.identifier);
+      const localBaseTime = pagesMeta.pages[localPage.identifier]?.updatedAt;
+      if (remotePage && localBaseTime) {
+        if (new Date(remotePage.updatedAt) > new Date(localBaseTime)) {
+          staleItems.push(`Page: ${localPage.identifier} (Remote updated: ${remotePage.updatedAt})`);
+        }
+      }
+    });
+  }
+  if (navigationMeta) {
+    localContent.navigation?.menus.forEach((localMenu) => {
+      const remoteMenu = remoteContent.navigation.find((m) => m.name === localMenu.name);
+      const localBaseTime = navigationMeta.menus[localMenu.name]?.updatedAt;
+      if (remoteMenu && localBaseTime) {
+        if (new Date(remoteMenu.updatedAt) > new Date(localBaseTime)) {
+          staleItems.push(`Navigation: ${localMenu.name} (Remote updated: ${remoteMenu.updatedAt})`);
+        }
+      }
+    });
+  }
+  return staleItems;
+}
+var pushCommand = new commander.Command("push").description("Push content to CMS").argument("[scope]", "What to push: entries, pages, navigation, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--content-dir <dir>", "Content directory (overrides config)").option("--dry-run", "Show what would be pushed without making changes").option("--yes", "Skip confirmation prompt (required for --remote)").option("--force", "Push even if remote content is newer (skip stale check)").option("--allow-truncated", "Push even if remote content was truncated (may cause incomplete sync)").option("--json-diff [mode]", "Output JSON diff (summary or full)", "summary").addHelpText("after", `
+Examples:
+  $ riverbankcms push                         # Push all content
+  $ riverbankcms push --dry-run               # Preview changes
+  $ riverbankcms push --remote --yes          # Push to production
+  $ riverbankcms push entries                 # Push all entries
+  $ riverbankcms push entries blog-post       # Push specific content type
+  $ riverbankcms push pages                   # Push pages with blocks
+  $ riverbankcms push navigation              # Push navigation menus
+  $ riverbankcms push --content-dir ./src/content  # Custom content directory
+  $ riverbankcms push --dry-run --json-diff=summary  # JSON summary for agents
+  $ riverbankcms push --dry-run --json-diff=full     # Full JSON before/after payloads
+
+Sync Behavior:
+  Content sync is controlled by your riverbank.config.ts:
+  - sync.existingEntries: 'skip' (default) or 'update'
+  - sync.contentTarget: 'draft' (default) or 'publish'
+
+Safety:
+  - Stale detection: aborts if remote content is newer than last pull (use --force to override)
+  - Truncation: aborts if remote has >100 entries per type (use --allow-truncated to override)
+  - Remote environment (--remote): defaults to dry-run, requires --yes to execute
+`).action(async (scope, type, options, command) => {
+  const { output, isRemote, globalOpts } = getOutputContext(command);
+  let dryRun = options.dryRun ?? false;
+  const jsonDiffMode = options.jsonDiff ? options.jsonDiff === "summary" || options.jsonDiff === "full" ? options.jsonDiff : null : void 0;
+  if (options.jsonDiff && !jsonDiffMode) {
+    output.error("Invalid value for --json-diff. Use summary or full.");
+    return;
+  }
+  if (isRemote && !options.yes) {
+    dryRun = true;
+    output.info("Remote push defaults to dry-run mode. Use --yes to apply changes.");
+  }
+  try {
+    const cliConfig = await loadCliConfig();
+    const contentDir = path9__namespace.resolve(options.contentDir ?? cliConfig.contentDir);
+    if (!await contentDirExists(contentDir)) {
+      return output.error(`Content directory not found: ${contentDir}`, {
+        suggestion: 'Run "riverbankcms pull" first to download content, or specify a different directory with --content-dir'
+      });
+    }
+    const summary = await getContentSummary(contentDir);
+    if (summary.totalEntries === 0 && summary.pageCount === 0 && !summary.hasNavigation) {
+      output.warn("No content found to push");
+      return;
+    }
+    const env = loadEnvironment(isRemote);
+    const client = createManagementClient({
+      dashboardUrl: env.dashboardUrl,
+      managementApiKey: env.managementApiKey,
+      siteId: env.siteId
+    });
+    output.info("Reading local content...");
+    const localContent = await readAllContent(contentDir);
+    const pushScope = scope?.toLowerCase() ?? "all";
+    const filteredLocal = filterLocalContent(localContent, pushScope, type);
+    output.info("Fetching remote content for comparison...");
+    const remoteContent = await client.pull.all();
+    if (remoteContent.meta.truncated) {
+      output.warn("Warning: Remote content was truncated due to size limits.");
+      output.warn(
+        remoteContent.meta.truncationMessage ?? "Some content types have more than 100 entries. Results may be incomplete."
+      );
+      if (!options.allowTruncated) {
+        output.error(
+          "Push aborted due to truncated remote content.",
+          { suggestion: "Use --allow-truncated to push anyway, or push specific content types: riverbankcms push entries blog-post" }
+        );
+        return;
+      }
+      output.warn("Proceeding with push despite truncation (--allow-truncated flag used)");
+    }
+    if (!options.force) {
+      output.info("Checking for stale content...");
+      const [localMeta, pagesMeta, navigationMeta] = await Promise.all([
+        readAllMeta(contentDir),
+        readPagesMeta(contentDir),
+        readNavigationMeta(contentDir)
+      ]);
+      const staleItems = checkForStaleContent(filteredLocal, localMeta, pagesMeta, navigationMeta, remoteContent);
+      if (staleItems.length > 0) {
+        output.warn("WARNING: The following remote content has changed since you last pulled:");
+        staleItems.forEach((item) => output.warn(`  - ${item}`));
+        output.error(
+          "Push aborted to prevent overwriting newer content.",
+          { suggestion: 'Run "riverbankcms pull" to update your local content, or use --force to overwrite.' }
+        );
+        return;
+      }
+    }
+    output.info("Calculating changes...");
+    const diff = calculateDiff(filteredLocal, remoteContent, {
+      existingEntries: cliConfig.sync.existingEntries
+    });
+    if (!hasPendingChanges(diff)) {
+      output.success("No changes detected - content is already in sync");
+      return;
+    }
+    displayDiff(
+      output,
+      diff,
+      cliConfig,
+      dryRun,
+      isRemote,
+      globalOpts.json ?? false,
+      jsonDiffMode ?? void 0,
+      filteredLocal,
+      remoteContent
+    );
+    if (dryRun) {
+      output.info("\nUse --yes (for remote) or remove --dry-run (for local) to apply changes.");
+      return;
+    }
+    output.info("\nApplying changes...");
+    const result = await executeSyncPlan(
+      client,
+      diff,
+      filteredLocal,
+      { dryRun: false, contentTarget: cliConfig.sync.contentTarget },
+      output
+    );
+    reportSyncResults(output, result, result.errors.length > 0);
+  } catch (error) {
+    handleCommandError(error, output);
+  }
+});
+var formatEntryRow = (entry) => [
+  entry.identifier,
+  entry.status,
+  entry.hasUnpublishedChanges ? "Yes" : "No",
+  entry.slug ?? "-",
+  formatDateShort(entry.updatedAt)
+];
+var upsertCommand = new commander.Command("upsert").description("Create or update an entry").argument("<type>", "Content type").argument("<identifier>", "Entry identifier").option("--data <json>", "Entry data as JSON string").option("--file <path>", "Path to JSON file with entry data").option("--slug <slug>", "Entry slug (defaults to identifier)").option("--title <title>", "Entry title").action(
+  withErrorHandling(async (type, identifier, options, command) => {
+    const { output, client } = createCommandContext(command);
+    const data = await parseJsonData(options);
+    output.info(`Upserting entry: ${type}/${identifier}`);
+    const entry = await client.entries.upsert({
+      contentType: type,
+      identifier,
+      data,
+      slug: options.slug,
+      title: options.title
+    });
+    output.success(`Entry upserted: ${entry.identifier}`, {
+      id: entry.id,
+      identifier: entry.identifier,
+      contentType: entry.contentType,
+      status: entry.status
+    });
+  })
+);
+var publishCommand = createPublishCommand({
+  resourceName: "entry",
+  args: ["type", "identifier"],
+  action: (client, type, identifier) => client.entries.publish(type, identifier)
+});
+var unpublishCommand = createUnpublishCommand({
+  resourceName: "entry",
+  args: ["type", "identifier"],
+  action: (client, type, identifier) => client.entries.unpublish(type, identifier)
+});
+var getCommand = createGetCommand({
+  resourceName: "entry",
+  args: ["type", "identifier"],
+  get: (client, type, identifier) => client.entries.get(type, identifier),
+  formatOutput: (entry) => ({
+    id: entry.id,
+    contentType: entry.contentType,
+    status: entry.status,
+    hasUnpublishedChanges: entry.hasUnpublishedChanges,
+    slug: entry.slug,
+    data: entry.data,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    publishedAt: entry.publishedAt
+  })
+});
+var listCommand = createListCommand({
+  resourceName: "entry",
+  resourceNamePlural: "entries",
+  args: ["type"],
+  hasPagination: true,
+  list: (client, args, pagination) => client.entries.list(args[0], pagination),
+  tableHeaders: ["Identifier", "Status", "Unpublished Changes", "Slug", "Updated"],
+  formatRow: formatEntryRow
+});
+var entryCommand = new commander.Command("entry").description("Manage content entries").addHelpText("after", `
+Examples:
+  $ riverbankcms entry upsert blog-post my-post --data '{"title": "Hello"}'
+  $ riverbankcms entry upsert blog-post my-post --file ./post-data.json
+  $ riverbankcms entry publish blog-post my-post
+  $ riverbankcms entry unpublish blog-post my-post
+  $ riverbankcms entry get blog-post my-post
+  $ riverbankcms entry list blog-post --limit 10 --page 1
+`).addCommand(upsertCommand).addCommand(publishCommand).addCommand(unpublishCommand).addCommand(getCommand).addCommand(listCommand);
+var formatPageRow = (page) => [
+  page.identifier ?? "(no identifier)",
+  page.title,
+  page.path,
+  page.status,
+  page.hasUnpublishedChanges ? "Yes" : "No",
+  formatDateShort(page.updatedAt)
+];
+var upsertCommand2 = new commander.Command("upsert").description("Create or update a page").argument("<identifier>", "Page identifier").requiredOption("--title <title>", "Page title").requiredOption("--path <path>", "Page path (e.g., /about)").option("--seo-title <title>", "SEO title").option("--seo-description <description>", "SEO description").action(
+  withErrorHandling(async (identifier, options, command) => {
+    const { output, client } = createCommandContext(command);
+    output.info(`Upserting page: ${identifier}`);
+    const page = await client.pages.upsert({
+      identifier,
+      title: options.title,
+      path: options.path,
+      seoTitle: options.seoTitle,
+      seoDescription: options.seoDescription
+    });
+    output.success(`Page upserted: ${page.identifier}`, {
+      id: page.id,
+      identifier: page.identifier,
+      path: page.path,
+      status: page.status
+    });
+  })
+);
+var publishCommand2 = createPublishCommand({
+  resourceName: "page",
+  args: ["identifier"],
+  action: (client, identifier) => client.pages.publish(identifier)
+});
+var unpublishCommand2 = createUnpublishCommand({
+  resourceName: "page",
+  args: ["identifier"],
+  action: (client, identifier) => client.pages.unpublish(identifier)
+});
+var getCommand2 = createGetCommand({
+  resourceName: "page",
+  args: ["identifier"],
+  get: (client, identifier) => client.pages.get(identifier),
+  formatOutput: (page) => ({
+    id: page.id,
+    title: page.title,
+    path: page.path,
+    status: page.status,
+    hasUnpublishedChanges: page.hasUnpublishedChanges,
+    createdAt: page.createdAt,
+    updatedAt: page.updatedAt,
+    publishedAt: page.publishedAt
+  })
+});
+var listCommand2 = createListCommand({
+  resourceName: "page",
+  resourceNamePlural: "pages",
+  args: [],
+  hasPagination: true,
+  list: (client, _args, pagination) => client.pages.list(pagination),
+  tableHeaders: ["Identifier", "Title", "Path", "Status", "Unpublished Changes", "Updated"],
+  formatRow: formatPageRow
+});
+var pageCommand = new commander.Command("page").description("Manage pages").addHelpText("after", `
+Examples:
+  $ riverbankcms page upsert about --title "About Us" --path /about
+  $ riverbankcms page upsert about --title "About Us" --path /about --seo-title "About Our Company"
+  $ riverbankcms page publish about
+  $ riverbankcms page unpublish about
+  $ riverbankcms page get about
+  $ riverbankcms page list --limit 10 --page 1
+`).addCommand(upsertCommand2).addCommand(publishCommand2).addCommand(unpublishCommand2).addCommand(getCommand2).addCommand(listCommand2);
+var formatBlockRow = (block) => [
+  block.identifier ?? "(no identifier)",
+  block.kind,
+  String(block.position),
+  formatDateShort(block.updatedAt)
+];
+var upsertCommand3 = new commander.Command("upsert").description("Create or update a block on a page").argument("<page-identifier>", "Page identifier").argument("<block-identifier>", "Block identifier").requiredOption("--kind <kind>", "Block kind (e.g., block.hero, block.bodyText)").option("--data <json>", "Block data as JSON string").option("--file <path>", "Path to JSON file with block data").option("--position <n>", "Block position (0-indexed)").action(
+  withErrorHandling(
+    async (pageIdentifier, blockIdentifier, options, command) => {
+      const { output, client } = createCommandContext(command);
+      const data = await parseJsonData(options);
+      output.info(`Upserting block: ${pageIdentifier}/${blockIdentifier}`);
+      const block = await client.blocks.upsert(pageIdentifier, {
+        identifier: blockIdentifier,
+        kind: options.kind,
+        data,
+        position: options.position ? parseInt(options.position, 10) : void 0
+      });
+      output.success(`Block upserted: ${block.identifier}`, {
+        id: block.id,
+        identifier: block.identifier,
+        kind: block.kind,
+        position: block.position
+      });
+    }
+  )
+);
+var reorderCommand = new commander.Command("reorder").description("Reorder blocks on a page").argument("<page-identifier>", "Page identifier").argument("<identifiers...>", "Block identifiers in desired order").action(
+  withErrorHandling(
+    async (pageIdentifier, identifiers, _options, command) => {
+      const { output, client } = createCommandContext(command);
+      if (identifiers.length < 2) {
+        return output.error("At least 2 block identifiers are required for reordering");
+      }
+      output.info(`Reordering blocks on page: ${pageIdentifier}`);
+      await client.blocks.reorder(pageIdentifier, identifiers);
+      output.success(`Blocks reordered`, {
+        page: pageIdentifier,
+        order: identifiers
+      });
+    }
+  )
+);
+var listCommand3 = createListCommand({
+  resourceName: "block",
+  resourceNamePlural: "blocks",
+  args: ["page-identifier"],
+  hasPagination: false,
+  list: async (client, args) => ({ items: await client.blocks.list(args[0]) }),
+  tableHeaders: ["Identifier", "Kind", "Position", "Updated"],
+  formatRow: formatBlockRow
+});
+var getCommand3 = createGetCommand({
+  resourceName: "block",
+  args: ["page-identifier", "block-identifier"],
+  get: (client, pageIdentifier, blockIdentifier) => client.blocks.get(pageIdentifier, blockIdentifier),
+  formatOutput: (block) => ({
+    id: block.id,
+    kind: block.kind,
+    position: block.position,
+    data: block.data,
+    createdAt: block.createdAt,
+    updatedAt: block.updatedAt
+  })
+});
+var blockCommand = new commander.Command("block").description("Manage page blocks").addHelpText("after", `
+Examples:
+  $ riverbankcms block upsert home hero-main --kind block.hero --data '{"heading": "Welcome"}'
+  $ riverbankcms block upsert home hero-main --kind block.hero --file ./hero-data.json
+  $ riverbankcms block reorder home hero-main content-section cta-bottom
+  $ riverbankcms block list home
+  $ riverbankcms block get home hero-main
+
+To delete a block, use: riverbankcms delete block <page-id> <block-id>
+`).addCommand(upsertCommand3).addCommand(reorderCommand).addCommand(listCommand3).addCommand(getCommand3);
+var formatMenuRow = (menu) => {
+  const itemCount = countItems(menu.items);
+  return [
+    menu.name,
+    String(itemCount),
+    formatDateShort(menu.updatedAt)
+  ];
+};
+function countItems(items) {
+  let count = items.length;
+  for (const item of items) {
+    if (item.children) {
+      count += countItems(item.children);
+    }
+  }
+  return count;
+}
+var upsertCommand4 = new commander.Command("upsert").description("Create or update a navigation menu").argument("<menu-name>", "Navigation menu name").option("--file <path>", "Path to JSON file with menu items").option("--data <json>", "Menu items as JSON string").action(
+  withErrorHandling(async (menuName, options, command) => {
+    const { output, client } = createCommandContext(command);
+    const items = await parseJsonArray(options);
+    output.info(`Upserting navigation menu: ${menuName}`);
+    const menu = await client.navigation.upsert({
+      name: menuName,
+      items
+    });
+    output.success(`Navigation menu upserted: ${menu.name}`, {
+      id: menu.id,
+      name: menu.name,
+      itemCount: countItems(menu.items)
+    });
+  })
+);
+var getCommand4 = createGetCommand({
+  resourceName: "navigation menu",
+  args: ["menu-name"],
+  get: (client, menuName) => client.navigation.get(menuName),
+  formatOutput: (menu) => ({
+    id: menu.id,
+    name: menu.name,
+    items: menu.items,
+    createdAt: menu.createdAt,
+    updatedAt: menu.updatedAt
+  })
+});
+var listCommand4 = createListCommand({
+  resourceName: "navigation menu",
+  resourceNamePlural: "navigation menus",
+  args: [],
+  hasPagination: false,
+  list: async (client) => ({ items: await client.navigation.list() }),
+  tableHeaders: ["Name", "Items", "Updated"],
+  formatRow: formatMenuRow
+});
+var navigationCommand = new commander.Command("navigation").description("Manage navigation menus").addHelpText("after", `
+Examples:
+  $ riverbankcms navigation upsert main --file ./main-nav.json
+  $ riverbankcms navigation upsert footer --data '[{"label": "Home", "url": "/"}]'
+  $ riverbankcms navigation get main
+  $ riverbankcms navigation list
+
+JSON file format:
+  {
+    "items": [
+      { "label": "Home", "url": "/" },
+      { "label": "About", "url": "/about", "children": [
+        { "label": "Team", "url": "/about/team" }
+      ]}
+    ]
+  }
+`).addCommand(upsertCommand4).addCommand(getCommand4).addCommand(listCommand4);
+var deleteEntryCommand = new commander.Command("entry").description("Delete a content entry").argument("<type>", "Content type").argument("<identifier>", "Entry identifier").option("--yes", "Skip confirmation prompt (required for --remote)").action(
+  withConfirmation(
+    (type, identifier) => `Delete entry "${type}/${identifier}"?`,
+    async (ctx, type, identifier) => {
+      ctx.output.info(`Deleting entry: ${type}/${identifier}`);
+      await ctx.client.entries.delete(type, identifier);
+      ctx.output.success(`Entry deleted: ${identifier}`);
+    }
+  )
+);
+var deleteBlockCommand = new commander.Command("block").description("Delete a block from a page").argument("<page-identifier>", "Page identifier").argument("<block-identifier>", "Block identifier").option("--yes", "Skip confirmation prompt (required for --remote)").action(
+  withConfirmation(
+    (pageIdentifier, blockIdentifier) => `Delete block "${blockIdentifier}" from page "${pageIdentifier}"?`,
+    async (ctx, pageIdentifier, blockIdentifier) => {
+      ctx.output.info(`Deleting block: ${pageIdentifier}/${blockIdentifier}`);
+      await ctx.client.blocks.delete(pageIdentifier, blockIdentifier);
+      ctx.output.success(`Block deleted: ${blockIdentifier}`);
+    }
+  )
+);
+var deleteCommand = new commander.Command("delete").description("Delete content from CMS").addHelpText("after", `
+Examples:
+  $ riverbankcms delete entry blog-post my-post
+  $ riverbankcms delete entry blog-post my-post --yes
+  $ riverbankcms delete block home hero-main --yes
+  $ riverbankcms delete entry blog-post my-post --remote --yes
+
+Note: Remote delete operations require --yes flag for safety.
+`).addCommand(deleteEntryCommand).addCommand(deleteBlockCommand);
+
+// src/cli/preview/template.ts
+function buildPreviewHtml({ html, cssText, title }) {
+  const safeTitle = title ?? "Block Preview";
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${safeTitle}</title>
+    <style>
+      ${cssText}
+    </style>
+  </head>
+  <body>
+    ${html}
+  </body>
+</html>`;
+}
+
+// src/cli/preview/playwright.config.ts
+var config = {
+  use: {
+    viewport: { width: 1280, height: 720 },
+    deviceScaleFactor: 2,
+    colorScheme: "light"
+  }
+};
+var playwright_config_default = config;
+
+// src/cli/preview/screenshot.ts
+async function captureScreenshot(options) {
+  const { html, outputPath, viewport } = options;
+  let playwright;
+  try {
+    playwright = await import('playwright');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Playwright is not installed. Install it to use --screenshot. (${message})`);
+  }
+  const browser = await playwright.chromium.launch();
+  const page = await browser.newPage({
+    viewport: viewport ?? playwright_config_default.use.viewport,
+    deviceScaleFactor: playwright_config_default.use.deviceScaleFactor,
+    colorScheme: playwright_config_default.use.colorScheme
+  });
+  await page.setContent(html, { waitUntil: "load" });
+  await page.screenshot({ path: path9__namespace.resolve(outputPath), fullPage: true });
+  await browser.close();
+}
+function resolveOutputMode(options) {
+  const modes = [options.terminal, options.open, options.screenshot].filter(Boolean).length;
+  if (modes > 1) {
+    throw new Error("Choose only one output mode: --terminal, --open, or --screenshot");
+  }
+  if (options.open) return "open";
+  if (options.screenshot) return "screenshot";
+  return "terminal";
+}
+async function writePreviewHtmlFile(html) {
+  const dir = await fs3__namespace.mkdtemp(path9__namespace.join(os__namespace.tmpdir(), "riverbank-preview-"));
+  const filePath = path9__namespace.join(dir, "index.html");
+  await fs3__namespace.writeFile(filePath, html, "utf-8");
+  return filePath;
+}
+async function openPreviewFile(filePath) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    await runCommand("open", [filePath]);
+    return;
+  }
+  if (platform === "win32") {
+    await runCommand("cmd", ["/c", "start", '""', filePath]);
+    return;
+  }
+  await runCommand("xdg-open", [filePath]);
+}
+function runCommand(command, args) {
+  return new Promise((resolve8, reject) => {
+    const child = child_process.spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", reject);
+    child.unref();
+    resolve8();
+  });
+}
+
+// src/cli/commands/preview.ts
+async function readCssFiles(paths) {
+  if (!paths || paths.length === 0) return "";
+  const chunks = await Promise.all(paths.map(async (filePath) => {
+    const resolved = path9__namespace.resolve(filePath);
+    const { readFile: readFile4 } = await import('fs/promises');
+    return readFile4(resolved, "utf-8");
+  }));
+  return chunks.join("\n");
+}
+function formatValidationIssues(response) {
+  return response.validation.issues.map((issue) => {
+    const pathText = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${pathText}: ${issue.message}`;
+  });
+}
+var previewCommand = new commander.Command("preview").description("Render a block preview").argument("<kind>", "Block kind (e.g., block.hero)").option("--data <json>", "Inline JSON string for block content").option("--file <path>", "Path to JSON file with block content").option("--validation <mode>", "Validation mode (strict or lenient)", "strict").option("--preview-stage <stage>", "Content stage (published or preview)", "preview").option("--theme-id <id>", "Theme ID override").option("--page-id <id>", "Page ID context for loaders").option("--content-entry-id <id>", "Content entry ID context for loaders").option("--css <paths...>", "Append compiled CSS files for site-specific utilities").option("--terminal", "Print HTML output to the terminal (default)").option("--open", "Open the preview in a browser").option("--screenshot", "Capture a screenshot using Playwright").option("--output <path>", "Screenshot output path (default: ./block-preview.png)").action(
+  withErrorHandling(async (kind, options, command) => {
+    const { output, client, isJsonOutput } = createCommandContext(command);
+    const mode = resolveOutputMode(options);
+    const data = await parseJsonData({ data: options.data, file: options.file });
+    const response = await client.preview.block({
+      kind,
+      data,
+      themeId: options.themeId,
+      pageId: options.pageId,
+      contentEntryId: options.contentEntryId,
+      previewStage: options.previewStage,
+      validationMode: options.validation ?? "strict"
+    });
+    const extraCss = await readCssFiles(options.css);
+    const cssText = extraCss ? `${response.cssText}
+${extraCss}` : response.cssText;
+    const htmlDocument = buildPreviewHtml({ html: response.html, cssText });
+    if (!response.validation.valid) {
+      const issues = formatValidationIssues(response);
+      output.warn("Block validation failed (lenient mode)", { issues });
+    }
+    if (isJsonOutput) {
+      return output.json({ success: true, data: { ...response, cssText } });
+    }
+    if (mode === "open") {
+      const filePath = await writePreviewHtmlFile(htmlDocument);
+      await openPreviewFile(filePath);
+      output.success("Opened preview in browser", { filePath });
+      return;
+    }
+    if (mode === "screenshot") {
+      const outputPath = options.output ?? path9__namespace.resolve(process.cwd(), "block-preview.png");
+      await captureScreenshot({ html: htmlDocument, outputPath });
+      output.success("Screenshot saved", { outputPath });
+      return;
+    }
+    output.info("Block preview HTML:");
+    console.log(htmlDocument);
+  })
+);
+
+// src/cli/init-docs/templates.ts
+var GENERATED_START = "<!-- RIVERBANK-GENERATED-START -->";
+var GENERATED_END = "<!-- RIVERBANK-GENERATED-END -->";
+function getGeneratedMarkers() {
+  return { start: GENERATED_START, end: GENERATED_END };
+}
+function buildSchemaTemplate(state) {
+  const header = [
+    "# Site Schema",
+    "",
+    "This document captures the content model and SDK configuration for this site.",
+    "The generated section is updated by `riverbankcms init-docs`.",
+    "",
+    renderConfigGuideSection(),
+    ""
+  ].join("\n");
+  const generated = buildSchemaGeneratedSection(state);
+  return `${header}${GENERATED_START}
+${generated}
+${GENERATED_END}
+`;
+}
+function buildBlockTypesTemplate() {
+  const header = [
+    "# System Block Types",
+    "",
+    "Reference list of all built-in CMS block types.",
+    "The generated section is updated by `riverbankcms init-docs`.",
+    ""
+  ].join("\n");
+  const generated = buildBlockTypesGeneratedSection();
+  return `${header}${GENERATED_START}
+${generated}
+${GENERATED_END}
+`;
+}
+function buildSchemaGeneratedSection(state) {
+  if (!state.config) {
+    return [
+      "## Status",
+      "",
+      state.errorMessage ?? "No SDK config available.",
+      ""
+    ].join("\n");
+  }
+  const config3 = state.config;
+  const sections = [];
+  sections.push(renderContentTypesSection(config3));
+  sections.push(renderCustomBlocksSection(config3.customBlocks ?? []));
+  sections.push(renderBlockFieldExtensionsSection(config3.blockFieldExtensions));
+  sections.push(renderBlockFieldOptionsSection(config3.blockFieldOptions));
+  return sections.filter(Boolean).join("\n");
+}
+function buildBlockTypesGeneratedSection() {
+  const definitions = listBlockDefinitions();
+  const sections = ["## System Blocks", ""];
+  for (const definition of definitions) {
+    const manifest = definition.manifest;
+    sections.push(`### ${manifest.name}`);
+    sections.push("");
+    sections.push(`- Title: ${manifest.title}`);
+    if (manifest.description) {
+      sections.push(`- Description: ${manifest.description}`);
+    }
+    if (manifest.category) {
+      sections.push(`- Category: ${manifest.category}`);
+    }
+    if (manifest.tags && manifest.tags.length > 0) {
+      sections.push(`- Tags: ${manifest.tags.join(", ")}`);
+    }
+    if (manifest.contentTypes && manifest.contentTypes.length > 0) {
+      sections.push(`- Content Types: ${manifest.contentTypes.join(", ")}`);
+    }
+    if (manifest.behaviours?.paletteHidden) {
+      sections.push("- Palette Hidden: yes");
+    }
+    sections.push("");
+    sections.push("Fields:");
+    if (manifest.fields.length === 0) {
+      sections.push("- (none)");
+    } else {
+      sections.push(...renderFieldList(manifest.fields, 0));
+    }
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function renderContentTypesSection(config3) {
+  const contentTypes = config3.content?.contentTypes ?? [];
+  const lines = ["## Content Types", ""];
+  if (contentTypes.length === 0) {
+    lines.push("No content types defined.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const type of contentTypes) {
+    lines.push(`### ${type.name} (${type.key})`);
+    lines.push("");
+    if (type.description) {
+      lines.push(type.description);
+      lines.push("");
+    }
+    lines.push(`- Has Pages: ${type.hasPages ? "yes" : "no"}`);
+    if (type.routePattern) lines.push(`- Route Pattern: ${type.routePattern}`);
+    if (type.titleField) lines.push(`- Title Field: ${type.titleField}`);
+    if (type.isSingleton) lines.push("- Singleton: yes");
+    lines.push("");
+    lines.push("Fields:");
+    if (type.fields.length === 0) {
+      lines.push("- (none)");
+    } else {
+      lines.push(...renderFieldList(type.fields, 0));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderConfigGuideSection() {
+  return [
+    "## riverbank.config.ts Guide",
+    "",
+    "Use `riverbank.config.ts` as the source of truth for the site schema, custom blocks, and CLI behavior.",
+    "This section is static guidance for agents; the generated section below shows the live config.",
+    "",
+    "### Field Overrides (blockFieldOptions)",
+    "",
+    "Use `blockFieldOptions` to override the *options* for existing `select` fields.",
+    "This only affects fields that use the `sdkSelect` UI widget (for example: the embed block layout picker).",
+    "",
+    "```ts",
+    "export default defineConfig({",
+    "  siteId: 'your-site-id',",
+    "  blockFieldOptions: {",
+    "    'block.embed': {",
+    "      layout: {",
+    "        options: [",
+    "          { value: 'showcase', label: 'Showcase Grid' },",
+    "          { value: 'list', label: 'Simple List' },",
+    "        ],",
+    "      },",
+    "    },",
+    "    'custom.featured-posts': {",
+    "      style: {",
+    "        options: [",
+    "          { value: 'grid', label: 'Grid' },",
+    "          { value: 'carousel', label: 'Carousel' },",
+    "        ],",
+    "      },",
+    "    },",
+    "  },",
+    "});",
+    "```",
+    "",
+    "### Block Field Extensions (blockFieldExtensions)",
+    "",
+    "Use `blockFieldExtensions` to add *new* fields to built-in system blocks.",
+    "Extended fields appear at the end of the block form and are available via `content` in `blockOverrides`.",
+    "",
+    "```ts",
+    "export default defineConfig({",
+    "  siteId: 'your-site-id',",
+    "  blockFieldExtensions: {",
+    "    'block.hero': {",
+    "      fields: [",
+    "        { id: 'videoBackground', type: 'media', label: 'Video Background', mediaKinds: ['video'] },",
+    "        { id: 'overlayOpacity', type: 'number', label: 'Overlay Opacity', defaultValue: 50 },",
+    "      ],",
+    "    },",
+    "    'block.bodyText': {",
+    "      fields: [",
+    "        { id: 'layout', type: 'select', label: 'Layout', defaultValue: 'default',",
+    "          options: [",
+    "            { value: 'default', label: 'Default' },",
+    "            { value: 'wide', label: 'Wide' },",
+    "          ],",
+    "        },",
+    "      ],",
+    "    },",
+    "  },",
+    "});",
+    "```",
+    "",
+    "Rules:",
+    "- Only system blocks (`block.*`) can be extended.",
+    "- Extended field IDs must not collide with existing block fields.",
+    "- If `required: true`, you must set a `defaultValue` to avoid breaking existing blocks.",
+    "",
+    "### Custom Blocks (customBlocks)",
+    "",
+    "Use `customBlocks` to define new block types with their own fields.",
+    "Custom blocks must be rendered via `blockOverrides` in the SDK site.",
+    "",
+    "```ts",
+    "export default defineConfig({",
+    "  siteId: 'your-site-id',",
+    "  customBlocks: [",
+    "    {",
+    "      id: 'custom.team-member',",
+    "      title: 'Team Member',",
+    "      titleSource: 'name',",
+    "      description: 'Profile card with bio and photo',",
+    "      category: 'content',",
+    "      icon: 'User',",
+    "      fields: [",
+    "        { id: 'name', type: 'text', label: 'Name', required: true },",
+    "        { id: 'role', type: 'text', label: 'Role' },",
+    "        { id: 'photo', type: 'media', label: 'Photo', mediaKinds: ['image'] },",
+    "        { id: 'bio', type: 'richText', label: 'Bio' },",
+    "      ],",
+    "    },",
+    "  ],",
+    "});",
+    "```",
+    "",
+    "### Field Types (for customBlocks and blockFieldExtensions)",
+    "",
+    "All field definitions use the same `FieldDefinition` format as system blocks.",
+    "Supported `type` values:",
+    "",
+    "- `text`: Single or multiline text",
+    "- `richText`: Rich text editor (markdown or HTML)",
+    "- `media`: Image or video upload",
+    "- `boolean`: Toggle/checkbox",
+    "- `number`: Numeric input",
+    "- `date`: Date picker",
+    "- `time`: Time picker",
+    "- `datetime`: Date + time picker",
+    "- `slug`: Slug with optional source field",
+    "- `url`: URL input (optionally allow relative)",
+    "- `link`: Link picker",
+    "- `select`: Single or multi-select options",
+    "- `reference`: Reference another entry type",
+    "- `repeater`: Repeatable list of fields",
+    "- `group`: Group of fields",
+    "- `modal`: Fields inside a modal dialog",
+    "- `tabGroup`: Group fields by tabs",
+    "- `presetOrCustom`: Preset list with custom fallback",
+    "- `contentTypeSelect`: Content type picker (all/routable/nonRoutable)",
+    "- `entryPicker`: Pick a content entry",
+    "",
+    "Tip: For `repeater`, define either `schema.fields` (monomorphic) or `polymorphic: true` with `itemTypes`."
+  ].join("\n");
+}
+function renderCustomBlocksSection(customBlocks) {
+  const lines = ["## Custom Blocks", ""];
+  if (customBlocks.length === 0) {
+    lines.push("No custom blocks defined.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const block of customBlocks) {
+    lines.push(`### ${block.id}`);
+    lines.push("");
+    lines.push(`- Title: ${block.title}`);
+    if (block.description) lines.push(`- Description: ${block.description}`);
+    if (block.category) lines.push(`- Category: ${block.category}`);
+    if (block.tags && block.tags.length > 0) lines.push(`- Tags: ${block.tags.join(", ")}`);
+    lines.push("");
+    lines.push("Fields:");
+    if (block.fields.length === 0) {
+      lines.push("- (none)");
+    } else {
+      lines.push(...renderFieldList(block.fields, 0));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderBlockFieldExtensionsSection(extensions) {
+  const lines = ["## Block Field Extensions", ""];
+  if (!extensions || Object.keys(extensions).length === 0) {
+    lines.push("No block field extensions defined.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const [blockId, extension] of Object.entries(extensions)) {
+    lines.push(`### ${blockId}`);
+    lines.push("");
+    if (extension.fields.length === 0) {
+      lines.push("- (none)");
+    } else {
+      lines.push(...renderFieldList(extension.fields, 0));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderBlockFieldOptionsSection(options) {
+  const lines = ["## Block Field Options", ""];
+  if (!options || Object.keys(options).length === 0) {
+    lines.push("No block field options defined.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const [blockId, fields4] of Object.entries(options)) {
+    lines.push(`### ${blockId}`);
+    lines.push("");
+    for (const [fieldId, config3] of Object.entries(fields4)) {
+      lines.push(`- ${fieldId}`);
+      if (config3.options && config3.options.length > 0) {
+        lines.push(...renderOptionsList(config3.options, 1));
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function renderFieldList(fields4, depth) {
+  const lines = [];
+  const indent = "  ".repeat(depth);
+  for (const field of fields4) {
+    const required = field.required ? " required" : "";
+    const label = field.label ? ` - ${field.label}` : "";
+    lines.push(`${indent}- ${field.id} (${field.type})${required}${label}`);
+    if ("options" in field && Array.isArray(field.options) && field.options.length > 0) {
+      lines.push(...renderOptionsList(field.options, depth + 1));
+    }
+    if ("fields" in field && Array.isArray(field.fields)) {
+      lines.push(...renderFieldList(field.fields, depth + 1));
+    }
+    if ("schema" in field && field.schema && "fields" in field.schema) {
+      lines.push(...renderFieldList(field.schema.fields, depth + 1));
+    }
+    if ("tabs" in field && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        lines.push(`${indent}  - tab ${tab.id} (${tab.label})`);
+        lines.push(...renderFieldList(tab.fields, depth + 2));
+      }
+    }
+  }
+  return lines;
+}
+function renderOptionsList(options, depth) {
+  const indent = "  ".repeat(depth);
+  return options.map((option) => `${indent}- option: ${option.value} (${option.label})`);
+}
+
+// src/cli/init-docs/index.ts
+var AGENTS_START = "<!-- RIVERBANK-CONTEXT-START -->";
+var AGENTS_END = "<!-- RIVERBANK-CONTEXT-END -->";
+async function initDocs(options) {
+  const { rootDir, configPath, agentsPath, output } = options;
+  const docsDir = path9__namespace.join(rootDir, "docs");
+  const contextDir = path9__namespace.join(rootDir, "context");
+  const workflowsDir = path9__namespace.join(docsDir, "workflows");
+  const knowledgeDir = path9__namespace.join(contextDir, "knowledge");
+  const brandDir = path9__namespace.join(contextDir, "brand");
+  await ensureDir2(workflowsDir);
+  await ensureDir2(knowledgeDir);
+  await ensureDir2(brandDir);
+  await writeFileIfMissing(path9__namespace.join(docsDir, "cli-reference.md"), cliReferenceTemplate());
+  await writeFileIfMissing(path9__namespace.join(docsDir, "content-management.md"), contentManagementTemplate());
+  await writeFileIfMissing(path9__namespace.join(workflowsDir, "create-page.md"), workflowCreatePageTemplate());
+  await writeFileIfMissing(path9__namespace.join(workflowsDir, "add-block.md"), workflowAddBlockTemplate());
+  await writeFileIfMissing(path9__namespace.join(workflowsDir, "publish-workflow.md"), workflowPublishTemplate());
+  await writeFileIfMissing(path9__namespace.join(contextDir, "brief.md"), briefTemplate());
+  await writeFileIfMissing(path9__namespace.join(knowledgeDir, "README.md"), knowledgeTemplate());
+  await writeFileIfMissing(path9__namespace.join(brandDir, "README.md"), brandTemplate());
+  const { config: config3, errorMessage } = await loadConfig(configPath, output);
+  await upsertGeneratedDoc(
+    path9__namespace.join(docsDir, "schema.md"),
+    buildSchemaTemplate({ config: config3, errorMessage }),
+    buildSchemaGeneratedSection({ config: config3, errorMessage })
+  );
+  await upsertGeneratedDoc(
+    path9__namespace.join(docsDir, "block-types.md"),
+    buildBlockTypesTemplate(),
+    buildBlockTypesGeneratedSection()
+  );
+  await upsertAgentsSection(agentsPath);
+}
+async function loadConfig(configPath, output) {
+  if (!configPath) {
+    return { errorMessage: "No config path provided." };
+  }
+  try {
+    const { loadConfigFile: loadConfigFile2 } = await Promise.resolve().then(() => (init_load_config(), load_config_exports));
+    const rawConfig = await loadConfigFile2(configPath);
+    const parsed = riverbankSiteConfigSchema.safeParse(rawConfig);
+    if (!parsed.success) {
+      return { errorMessage: `Config validation failed: ${parsed.error.message}` };
+    }
+    return { config: parsed.data };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    output?.warn("Failed to load config; schema will be partial", { message });
+    return { errorMessage: message };
+  }
+}
+async function ensureDir2(dirPath) {
+  await fs3__namespace.mkdir(dirPath, { recursive: true });
+}
+async function writeFileIfMissing(filePath, contents) {
+  try {
+    await fs3__namespace.access(filePath);
+  } catch {
+    await fs3__namespace.writeFile(filePath, contents, "utf-8");
+  }
+}
+async function upsertGeneratedDoc(filePath, template, generatedSection) {
+  const markers = getGeneratedMarkers();
+  const contents = await readFileOrTemplate(filePath, template);
+  const updated = replaceMarkedSection(contents, markers.start, markers.end, generatedSection);
+  await fs3__namespace.writeFile(filePath, updated, "utf-8");
+}
+async function readFileOrTemplate(filePath, template) {
+  try {
+    return await fs3__namespace.readFile(filePath, "utf-8");
+  } catch {
+    return template;
+  }
+}
+function replaceMarkedSection(content, startMarker, endMarker, section2) {
+  const startIndex = content.indexOf(startMarker);
+  const endIndex = content.indexOf(endMarker);
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+    const trimmed = content.trimEnd();
+    return `${trimmed}
+
+${startMarker}
+${section2}
+${endMarker}
+`;
+  }
+  const before = content.slice(0, startIndex + startMarker.length);
+  const after = content.slice(endIndex);
+  return `${before}
+${section2}
+${after}`;
+}
+async function upsertAgentsSection(filePath) {
+  const content = await readFileOrTemplate(filePath, "# AGENTS.md\n");
+  const section2 = agentsSectionTemplate();
+  const updated = replaceMarkedSection(content, AGENTS_START, AGENTS_END, section2);
+  await fs3__namespace.writeFile(filePath, updated, "utf-8");
+}
+function cliReferenceTemplate() {
+  return [
+    "# CLI Reference",
+    "",
+    "Describe the SDK CLI commands available to agents.",
+    "",
+    "Include usage patterns, required flags, and common examples.",
+    ""
+  ].join("\n");
+}
+function contentManagementTemplate() {
+  return [
+    "# Content Management",
+    "",
+    "Describe how content is structured, edited, and published for this site.",
+    ""
+  ].join("\n");
+}
+function workflowCreatePageTemplate() {
+  return [
+    "# Workflow: Create a Page",
+    "",
+    "Describe the steps to create a page for this site.",
+    "",
+    "Include any required content types or blocks.",
+    ""
+  ].join("\n");
+}
+function workflowAddBlockTemplate() {
+  return [
+    "# Workflow: Add a Block",
+    "",
+    "Describe how to add blocks to an existing page.",
+    ""
+  ].join("\n");
+}
+function workflowPublishTemplate() {
+  return [
+    "# Workflow: Publish Content",
+    "",
+    "Describe how to publish content safely for this site.",
+    ""
+  ].join("\n");
+}
+function briefTemplate() {
+  return [
+    "# Site Brief",
+    "",
+    "Summarize the brand, tone, and goals for this site.",
+    ""
+  ].join("\n");
+}
+function knowledgeTemplate() {
+  return [
+    "# Knowledge Base",
+    "",
+    "Add domain knowledge, FAQs, and reference links for the site.",
+    ""
+  ].join("\n");
+}
+function brandTemplate() {
+  return [
+    "# Brand Assets",
+    "",
+    "List or link the brand assets available for this site.",
+    ""
+  ].join("\n");
+}
+function agentsSectionTemplate() {
+  return [
+    "## Riverbank SDK Context",
+    "",
+    "- This repo contains both the CMS and the SDK used by this site.",
+    "- Agents can suggest or implement CMS changes when needed, not just local workarounds.",
+    "- Use riverbank.config.ts as the source of truth for site schema and custom blocks.",
+    "",
+    "## Code Quality Guidelines (SDK + CMS)",
+    "",
+    "- Prefer functional, composable helpers over large classes.",
+    "- Keep changes small and DRY; remove old code instead of shimming.",
+    "- Keep route handlers thin and use helpers/services.",
+    "- Use typed API clients; avoid hardcoded URLs."
+  ].join("\n");
+}
+
+// src/cli/commands/init-docs.ts
+async function runInitDocs(options, command) {
+  const { output, isJsonOutput } = createCommandContext(command);
+  const rootDir = path9__namespace.resolve(options.path ?? ".riverbank");
+  const configPath = path9__namespace.resolve(options.config ?? path9__namespace.join(process.cwd(), "riverbank.config.ts"));
+  const agentsPath = path9__namespace.resolve(process.cwd(), "AGENTS.md");
+  await initDocs({
+    rootDir,
+    configPath,
+    agentsPath,
+    output
+  });
+  if (isJsonOutput) {
+    output.json({ success: true, data: { rootDir } });
+    return;
+  }
+  output.success("Agent docs initialized", { rootDir });
+}
+var initDocsCommand = new commander.Command("init-docs").description("Scaffold agent documentation and site context").option("--path <path>", "Destination directory (default: ./.riverbank)").option("--config <path>", "Path to riverbank.config.ts (default: ./riverbank.config.ts)").action(
+  withErrorHandling(async (options, command) => {
+    await runInitDocs(options, command);
+  })
+);
+var backfillCommand = new commander.Command("backfill").description("Backfill identifiers for pages, blocks, and entries that don't have one").addHelpText("after", `
+This command generates stable identifiers for content created before the SDK was available.
+Identifiers are generated from titles (slugified) and are idempotent - running this
+command multiple times won't overwrite existing identifiers.
+
+Examples:
+  $ riverbankcms identifiers backfill
+  $ riverbankcms identifiers backfill --remote
+`).action(
+  withErrorHandling(async (_options, command) => {
+    const { output, client } = createCommandContext(command);
+    output.info("Backfilling identifiers for pages, blocks, and entries...");
+    const result = await client.identifiers.backfill();
+    const totalUpdated = result.pages.pagesUpdated + result.blocks.total + result.entries.entriesUpdated;
+    if (totalUpdated === 0) {
+      output.success("All content already has identifiers - nothing to backfill");
+      return;
+    }
+    output.success("Backfill complete", {
+      pages: {
+        updated: result.pages.pagesUpdated,
+        identifiers: result.pages.identifiersAssigned
+      },
+      blocks: {
+        updated: result.blocks.total,
+        byPage: Object.keys(result.blocks.byPage).length > 0 ? result.blocks.byPage : void 0
+      },
+      entries: {
+        updated: result.entries.entriesUpdated,
+        identifiers: result.entries.identifiersAssigned
+      }
+    });
+  })
+);
+var identifiersCommand = new commander.Command("identifiers").description("Manage SDK identifiers").addHelpText("after", `
+Identifiers are stable, human-readable names used to reference content in the SDK.
+They are automatically generated when content is created via the SDK, but older
+content may need backfilling.
+
+Commands:
+  backfill    Generate identifiers for content that doesn't have one
+
+Examples:
+  $ riverbankcms identifiers backfill
+`).addCommand(backfillCommand);
+
+// src/cli/index.ts
+dotenv.config({ path: ".env.local" });
+dotenv.config({ path: ".env" });
+var program = new commander.Command();
+program.name("riverbankcms").description("Riverbank CMS SDK CLI - manage content and configuration").version("0.1.0").option("--json", "Output in JSON format for machine parsing").option("--quiet", "Minimal output (suppress non-essential messages)").option("--remote", "Use remote/production environment instead of local").addHelpText("after", `
+Environment Variables:
+  Local environment (default):
+    RIVERBANK_LOCAL_SITE_ID          Site ID for local development
+    RIVERBANK_LOCAL_DASHBOARD_URL    Dashboard URL (e.g., http://localhost:4000)
+    RIVERBANK_LOCAL_MGMT_API_KEY     Management API key (bld_mgmt_sk_...)
+
+  Remote environment (--remote):
+    RIVERBANK_REMOTE_SITE_ID         Site ID for production
+    RIVERBANK_REMOTE_DASHBOARD_URL   Dashboard URL (e.g., https://dashboard.riverbankcms.com)
+    RIVERBANK_REMOTE_MGMT_API_KEY    Management API key (bld_mgmt_sk_...)
+
+Examples:
+  $ riverbankcms push-config --api-key $RIVERBANK_API_KEY
+  $ riverbankcms pull                    # Pull all content from local
+  $ riverbankcms pull --remote           # Pull all content from production
+  $ riverbankcms pull entries blog-post  # Pull specific content type
+  $ riverbankcms push                    # Push content to local
+  $ riverbankcms push --remote --yes     # Push content to production
 
 Run 'riverbankcms <command> --help' for detailed options.
 `);
 program.addCommand(pushConfigCommand);
+program.addCommand(pullCommand);
+program.addCommand(pushCommand);
+program.addCommand(entryCommand);
+program.addCommand(pageCommand);
+program.addCommand(blockCommand);
+program.addCommand(navigationCommand);
+program.addCommand(deleteCommand);
+program.addCommand(previewCommand);
+program.addCommand(initDocsCommand);
+program.addCommand(identifiersCommand);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map