@botlr/cli 0.1.2 → 0.3.0

package/dist/index.js

@@ -4,6 +4,7 @@ import path from "path";
 var CONFIG_FILE = "botlr.config.json";
 var DEFAULT_FRAMEWORK = "react-next";
 var DEFAULT_SECTIONS_DIR = "components/sections";
+var DEFAULT_REGISTRY_FILE = "publisher-section-registry.ts";
 var ConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -61,6 +62,8 @@ async function loadConfig(cwd, overrides = {}, env = process.env) {
     appId,
     framework: overrides.framework ?? env.BOTLR_FRAMEWORK ?? file.framework ?? DEFAULT_FRAMEWORK,
     sectionsDir,
+    registryFile: path.resolve(sectionsDir, file.registryFile ?? DEFAULT_REGISTRY_FILE),
+    types: file.types !== false,
     apiKey: env.BOTLR_API_KEY || void 0,
     personalToken: env.BOTLR_PAT || void 0
   };
@@ -71,6 +74,12 @@ import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import path2 from "path";
 var LOCK_DIR = ".botlr";
 var LOCK_FILE = "sections.lock.json";
+function nextLockEntry(previous, fresh) {
+  if (previous && previous.scope === fresh.scope && previous.framework === fresh.framework && previous.version === fresh.version && previous.contentHash === fresh.contentHash) {
+    return { ...fresh, pulledAt: previous.pulledAt };
+  }
+  return fresh;
+}
 function lockPath(root) {
   return path2.join(root, LOCK_DIR, LOCK_FILE);
 }
@@ -94,7 +103,7 @@ async function writeLock(root, lock) {
 }
 async function updateLock(root, name, entry) {
   const lock = await readLock(root);
-  lock[name] = entry;
+  lock[name] = nextLockEntry(lock[name], entry);
   await writeLock(root, lock);
   return lock;
 }
@@ -165,13 +174,80 @@ function validateManifest(value, where = "manifest") {
   }
   return m;
 }
+var MANIFEST_KEY_ORDER = [
+  "section",
+  "framework",
+  "entry",
+  "exportName",
+  "files",
+  "title",
+  "description",
+  "category",
+  "icon",
+  "dependencies",
+  "schema"
+];
+var DEPENDENCIES_KEY_ORDER = ["npm", "internal"];
+function orderKeys(value, first) {
+  const out = {};
+  for (const key of first) {
+    if (key in value && value[key] !== void 0) out[key] = value[key];
+  }
+  for (const key of Object.keys(value).sort()) {
+    if (first.includes(key) || value[key] === void 0) continue;
+    out[key] = value[key];
+  }
+  return out;
+}
+function normalizeNested(value) {
+  if (Array.isArray(value)) return value.map(normalizeNested);
+  if (value && typeof value === "object") {
+    const record = value;
+    const ordered = orderKeys(record, []);
+    for (const key of Object.keys(ordered)) ordered[key] = normalizeNested(ordered[key]);
+    return ordered;
+  }
+  return value;
+}
+function normalizeManifest(manifest) {
+  const stripped = stripManifestState(manifest);
+  const ordered = orderKeys(stripped, MANIFEST_KEY_ORDER);
+  for (const key of Object.keys(ordered)) {
+    if (key === "dependencies" && ordered[key] && typeof ordered[key] === "object" && !Array.isArray(ordered[key])) {
+      const deps = orderKeys(ordered[key], DEPENDENCIES_KEY_ORDER);
+      for (const depKey of Object.keys(deps)) deps[depKey] = normalizeNested(deps[depKey]);
+      ordered[key] = deps;
+    } else {
+      ordered[key] = normalizeNested(ordered[key]);
+    }
+  }
+  return ordered;
+}
+function formatManifest(manifest) {
+  return `${JSON.stringify(normalizeManifest(manifest), null, 2)}
+`;
+}
+function manifestsEqual(a, b) {
+  return formatManifest(a) === formatManifest(b);
+}
 async function writeManifest(sectionsDir, name, manifest) {
   const file = manifestPath(sectionsDir, name);
   await mkdir2(sectionsDir, { recursive: true });
-  await writeFile2(file, `${JSON.stringify(stripManifestState(manifest), null, 2)}
-`, "utf8");
+  await writeFile2(file, formatManifest(manifest), "utf8");
   return file;
 }
+async function writeManifestIfChanged(sectionsDir, name, manifest) {
+  const file = manifestPath(sectionsDir, name);
+  try {
+    const existing = JSON.parse(await readFile3(file, "utf8"));
+    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+      if (manifestsEqual(existing, manifest)) return { file, changed: false };
+    }
+  } catch {
+  }
+  await writeManifest(sectionsDir, name, manifest);
+  return { file, changed: true };
+}
 async function readSectionFiles(sectionsDir, manifest) {
   return Promise.all(
     manifest.files.map(async (relative) => {
@@ -226,7 +302,7 @@ function remoteForLock(summary, lock) {
 // src/init.ts
 import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
 import path4 from "path";
-var REGISTRY_FILE = "publisher-section-registry.ts";
+var REGISTRY_FILE = DEFAULT_REGISTRY_FILE;
 function parseRegistry(source) {
   const importedFrom = /* @__PURE__ */ new Map();
   const importRe = /import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/g;
@@ -259,14 +335,105 @@ function parseDefinition(source) {
     const m = body.match(new RegExp(`(?:^|\\n)\\s*${key}\\s*:\\s*(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`));
     return m ? m[1] ?? m[2] ?? m[3] : void 0;
   };
+  const schemaName = body.match(/(?:^|\n)\s*schema\s*:\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*,?/)?.[1];
   return {
     name: field("name"),
     heading: field("heading"),
     category: field("category"),
     description: field("description"),
-    icon: field("icon")
+    icon: field("icon"),
+    ...schemaName ? { schemaName } : {}
   };
 }
+function splitTopLevel(body) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let current = "";
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quote) {
+      current += ch;
+      if (ch === "\\") current += body[++i] ?? "";
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "/" && body[i + 1] === "/") {
+      while (i < body.length && body[i] !== "\n") i++;
+      current += "\n";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+    else if ("([{".includes(ch)) depth++;
+    else if (")]}".includes(ch)) depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function enumValues(expr) {
+  const m = expr.match(/^z\.enum\(\s*\[([\s\S]*?)\]/);
+  if (!m) return null;
+  const values = [];
+  for (const raw of splitTopLevel(m[1])) {
+    const lit = raw.match(/^(?:"([^"]*)"|'([^']*)'|`([^`]*)`)$/);
+    if (!lit) return null;
+    values.push(lit[1] ?? lit[2] ?? lit[3]);
+  }
+  return values;
+}
+function zodFieldToSchemaField(expr) {
+  const source = expr.trim();
+  const optional = /\.(optional|nullable|nullish|default)\(/.test(source);
+  let field = null;
+  if (/^z\.string\(/.test(source)) field = { type: /\.(email)\(/.test(source) ? "email" : /\.(url)\(/.test(source) ? "url" : "text" };
+  else if (/^z\.number\(/.test(source)) field = { type: /\.int\(/.test(source) ? "integer" : "number" };
+  else if (/^z\.boolean\(/.test(source)) field = { type: "boolean" };
+  else if (/^z\.enum\(/.test(source)) {
+    const options = enumValues(source);
+    field = options ? { type: "select", options } : { type: "select" };
+  } else if (/^z\.array\(/.test(source)) field = { type: "array" };
+  else if (/^z\.(object|record)\(/.test(source)) field = { type: "json" };
+  else if (/^z\.union\(\s*\[\s*z\.string\(\)\s*,\s*z\.(any|object|record)\(/.test(source)) field = { type: "asset" };
+  if (!field) return null;
+  if (!optional) field.required = true;
+  const describe = source.match(/\.describe\(\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`)\s*\)/);
+  const label = describe ? describe[1] ?? describe[2] ?? describe[3] : void 0;
+  if (label) field.label = label;
+  return field;
+}
+function parseZodSchema(source, schemaName) {
+  const start = source.match(new RegExp(`(?:export\\s+)?const\\s+${schemaName}\\s*=\\s*z\\.object\\(\\s*\\{`));
+  if (!start || start.index === void 0) return null;
+  const open = start.index + start[0].length;
+  let depth = 1;
+  let end = -1;
+  for (let i = open; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    else if (ch === "}" || ch === ")" || ch === "]") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  const schema = {};
+  for (const entry of splitTopLevel(source.slice(open, end))) {
+    const m = entry.match(/^(?:"([^"]+)"|'([^']+)'|([A-Za-z_$][A-Za-z0-9_$]*))\s*:\s*([\s\S]+)$/);
+    if (!m) continue;
+    const field = zodFieldToSchemaField(m[4]);
+    if (field) schema[m[1] ?? m[2] ?? m[3]] = field;
+  }
+  return Object.keys(schema).length ? schema : null;
+}
 function parseImports(source) {
   const internal = /* @__PURE__ */ new Set();
   const npm = /* @__PURE__ */ new Set();
@@ -292,7 +459,7 @@ async function resolveImport(sectionsDir, spec) {
   return null;
 }
 async function deriveManifests(sectionsDir, options) {
-  const registrySource = await readFile4(path4.join(sectionsDir, REGISTRY_FILE), "utf8");
+  const registrySource = await readFile4(options.registryFile ?? path4.join(sectionsDir, DEFAULT_REGISTRY_FILE), "utf8");
   const entries = parseRegistry(registrySource);
   const out = [];
   for (const entry of entries) {
@@ -300,6 +467,7 @@ async function deriveManifests(sectionsDir, options) {
     if (!entryFile) continue;
     const source = await readFile4(entryFile, "utf8");
     const meta = parseDefinition(source);
+    const schema = meta?.schemaName ? parseZodSchema(source, meta.schemaName) : null;
     const imports = parseImports(source);
     const relative = path4.relative(sectionsDir, entryFile).split(path4.sep).join("/");
     const npm = {};
@@ -320,7 +488,8 @@ async function deriveManifests(sectionsDir, options) {
       dependencies: {
         ...Object.keys(npm).length ? { npm } : {},
         ...imports.internal.length ? { internal: imports.internal } : {}
-      }
+      },
+      ...schema ? { schema } : {}
     };
     out.push({ name: entry.slug, manifest, entryFile });
   }
@@ -340,14 +509,375 @@ async function readNpmVersions(dir) {
     }
   }
 }
-async function hasRegistry(sectionsDir) {
+async function hasRegistry(sectionsDir, registryFile) {
+  const file = registryFile ?? path4.join(sectionsDir, DEFAULT_REGISTRY_FILE);
   try {
-    return (await readdir2(sectionsDir)).includes(REGISTRY_FILE);
+    return (await readdir2(path4.dirname(file))).includes(path4.basename(file));
   } catch {
     return false;
   }
 }
 
+// src/registry.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+var SOURCE_EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+function importPathFor(registryFile, entryFile) {
+  const relative = path5.relative(path5.dirname(registryFile), entryFile).split(path5.sep).join("/");
+  const ext = path5.extname(relative);
+  const bare = SOURCE_EXTENSIONS2.includes(ext) ? relative.slice(0, -ext.length) : relative;
+  return bare.startsWith(".") ? bare : `./${bare}`;
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function addRegistryEntry(source, addition) {
+  const { slug, exportName, importPath } = addition;
+  if (!IDENTIFIER.test(exportName)) throw new Error(`'${exportName}' is not a valid export name`);
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  let out = source;
+  let addedImport = false;
+  let addedEntry = false;
+  const importRe = /^[ \t]*import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*(["'])([^"']+)\2[ \t]*;?[ \t]*$/gm;
+  const imports = [...out.matchAll(importRe)];
+  const alreadyImported = imports.some(
+    (m) => m[1].split(",").some((raw) => raw.trim().split(/\s+as\s+/).pop()?.trim() === exportName)
+  );
+  if (!alreadyImported) {
+    const last = imports.at(-1);
+    const quote = last?.[2] ?? '"';
+    const semicolon = last ? last[0].trimEnd().endsWith(";") : true;
+    const line = `import { ${exportName} } from ${quote}${importPath}${quote}${semicolon ? ";" : ""}`;
+    if (last) {
+      const end = last.index + last[0].length;
+      out = `${out.slice(0, end)}${eol}${line}${out.slice(end)}`;
+    } else {
+      out = `${line}${eol}${eol}${out}`;
+    }
+    addedImport = true;
+  }
+  const alreadyMapped = parseRegistry(out).some((e) => e.slug === slug) || hasEntry(out, slug);
+  if (!alreadyMapped) {
+    const object = findRegistryObject(out);
+    if (!object) throw new Error("could not find the registry object (`export const ... = { ... }`)");
+    const body = out.slice(object.bodyStart, object.bodyEnd);
+    const entryLines = body.split(/\r?\n/).filter((l) => /^\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_$-]+)\s*:/.test(l));
+    const lastEntry = entryLines.at(-1);
+    const indent = lastEntry?.match(/^\s*/)?.[0] ?? "  ";
+    const key = IDENTIFIER.test(slug) ? slug : `"${slug}"`;
+    const entryLine = `${indent}${key}: ${exportName},`;
+    let newBody = body;
+    if (lastEntry !== void 0) {
+      const stripped = lastEntry.replace(/\/\/.*$/, "").trimEnd();
+      if (!stripped.endsWith(",")) {
+        const at = newBody.lastIndexOf(lastEntry);
+        const fixed = lastEntry.replace(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_$-]+)\s*:\s*[A-Za-z0-9_$]+)/, "$1,");
+        newBody = `${newBody.slice(0, at)}${fixed}${newBody.slice(at + lastEntry.length)}`;
+      }
+    }
+    newBody = `${newBody.replace(/\s*$/, "")}${eol}${entryLine}`;
+    out = `${out.slice(0, object.bodyStart)}${newBody}${out.slice(object.bodyEnd)}`;
+    addedEntry = true;
+  }
+  return { source: out, changed: addedImport || addedEntry, addedImport, addedEntry };
+}
+function hasEntry(source, slug) {
+  const object = findRegistryObject(source);
+  if (!object) return false;
+  const body = source.slice(object.bodyStart, object.bodyEnd);
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*(?:"${escaped}"|'${escaped}'|${escaped})\\s*:`, "m").test(body);
+}
+function findRegistryObject(source) {
+  const open = source.match(/export\s+const\s+\w+\s*(?::[^=]*)?=\s*\{/) ?? source.match(/=\s*\{/);
+  if (!open || open.index === void 0) return null;
+  const bodyStart = open.index + open[0].length;
+  const close = /\r?\n\}/g;
+  close.lastIndex = bodyStart;
+  const closeMatch = close.exec(source);
+  if (!closeMatch) return null;
+  return { bodyStart, bodyEnd: closeMatch.index };
+}
+async function registerSection(sectionsDir, registryFile, manifest) {
+  const name = path5.basename(registryFile);
+  let source;
+  try {
+    source = await readFile5(registryFile, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { file: registryFile, changed: false, notice: `no ${name} in ${path5.dirname(registryFile)}, register the section yourself` };
+    }
+    throw error;
+  }
+  if (!manifest.exportName) {
+    return { file: registryFile, changed: false, notice: `manifest has no exportName, ${name} not updated` };
+  }
+  const importPath = importPathFor(registryFile, path5.resolve(sectionsDir, manifest.entry));
+  let edit;
+  try {
+    edit = addRegistryEntry(source, { slug: manifest.section, exportName: manifest.exportName, importPath });
+  } catch (error) {
+    return { file: registryFile, changed: false, notice: `${name} not updated: ${error.message}` };
+  }
+  if (edit.changed) await writeFile3(registryFile, edit.source, "utf8");
+  return { file: registryFile, changed: edit.changed, addedImport: edit.addedImport, addedEntry: edit.addedEntry };
+}
+
+// src/typegen.ts
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import path6 from "path";
+import {
+  isFieldSchema,
+  isFormBuilderSchema
+} from "@botlr/sdk";
+var PROPS_SUFFIX = ".props.ts";
+var STRING_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "markdown",
+  "richtext",
+  "string",
+  "email",
+  "tel",
+  "url",
+  "icon",
+  "color",
+  "date",
+  "datetime",
+  "timestamp",
+  "timestamptz",
+  "uuid"
+]);
+var NUMBER_TYPES = /* @__PURE__ */ new Set(["number", "integer", "currency"]);
+var BOOLEAN_TYPES = /* @__PURE__ */ new Set(["boolean"]);
+var STRING_LIST_TYPES = /* @__PURE__ */ new Set(["multiselect", "tags"]);
+var LIST_TYPES = /* @__PURE__ */ new Set(["array", "list", "repeater"]);
+var OBJECT_TYPES = /* @__PURE__ */ new Set(["json", "jsonb", "object"]);
+var REFERENCE_TYPES = /* @__PURE__ */ new Set([
+  "asset",
+  "asset-picker-image",
+  "asset-picker-file",
+  "asset-picker-video",
+  "media",
+  "document",
+  "page",
+  "post",
+  "reference",
+  "relation",
+  "entity_reference",
+  "app_instance",
+  "forum_thread"
+]);
+var REFERENCE_TYPE = "string | Record<string, unknown>";
+var OBJECT_TYPE = "Record<string, unknown>";
+var GROUP_NODE_TYPES = /* @__PURE__ */ new Set(["section", "fieldset", "composite", "group"]);
+function literal(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return null;
+}
+function optionUnion(options) {
+  if (!Array.isArray(options) || options.length === 0) return null;
+  const literals = [];
+  for (const option of options) {
+    const raw = option && typeof option === "object" ? option.value : option;
+    const lit = literal(raw);
+    if (lit === null) return null;
+    if (!literals.includes(lit)) literals.push(lit);
+  }
+  return literals.join(" | ");
+}
+function wrapArray(type) {
+  return /^[A-Za-z0-9_<>, ]+$/.test(type) ? `${type}[]` : `Array<${type}>`;
+}
+function tsTypeForField(field) {
+  const kind = typeof field.type === "string" ? field.type : "";
+  const multiple = field.multiple === true;
+  if (kind === "select") {
+    const union = optionUnion(field.options) ?? "string";
+    return multiple ? wrapArray(union) : union;
+  }
+  if (STRING_TYPES.has(kind)) return "string";
+  if (NUMBER_TYPES.has(kind)) return "number";
+  if (BOOLEAN_TYPES.has(kind)) return "boolean";
+  if (STRING_LIST_TYPES.has(kind)) return "string[]";
+  if (kind === "repeater" && Array.isArray(field.fields)) {
+    const items = collectFormBuilderFields(field.fields);
+    return items.length ? `Array<${inlineObject(items)}>` : "unknown[]";
+  }
+  if (LIST_TYPES.has(kind)) return "unknown[]";
+  if (OBJECT_TYPES.has(kind)) return OBJECT_TYPE;
+  if (REFERENCE_TYPES.has(kind)) return multiple ? `Array<${REFERENCE_TYPE}>` : REFERENCE_TYPE;
+  return "unknown";
+}
+function docFor(field) {
+  const doc = [];
+  for (const value of [field.label, field.helpText ?? field.description]) {
+    if (typeof value === "string" && value.trim()) doc.push(value.trim());
+  }
+  return doc;
+}
+function collectDslFields(schema) {
+  const out = [];
+  for (const [name, value] of Object.entries(schema)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const field = value;
+    out.push({ name, type: tsTypeForField(field), required: field.required === true, doc: docFor(field) });
+  }
+  return out;
+}
+function collectFormBuilderFields(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (!node || typeof node !== "object") continue;
+    if (GROUP_NODE_TYPES.has(node.type) && Array.isArray(node.children)) {
+      out.push(...collectFormBuilderFields(node.children));
+      continue;
+    }
+    const name = typeof node.name === "string" && node.name ? node.name : typeof node.key === "string" ? node.key : "";
+    if (!name) continue;
+    const kind = node.type === "field" ? node.fieldType ?? "" : node.fieldType ?? node.type;
+    const type = tsTypeForField({ type: kind, options: node.options, multiple: node.multiple, fields: node.fields });
+    out.push({ name, type, required: node.required === true, doc: docFor(node) });
+  }
+  return out;
+}
+function collectFields(schema) {
+  if (isFormBuilderSchema(schema)) return collectFormBuilderFields(schema.nodes);
+  if (isFieldSchema(schema)) return collectDslFields(schema);
+  return [];
+}
+function schemaFieldNames(schema) {
+  return collectFields(schema).map((f) => f.name);
+}
+var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function propertyKey(name) {
+  return IDENTIFIER_RE.test(name) ? name : JSON.stringify(name);
+}
+function inlineObject(fields) {
+  return `{ ${fields.map((f) => `${propertyKey(f.name)}${f.required ? "" : "?"}: ${f.type}`).join("; ")} }`;
+}
+function pascalCase(slug) {
+  const words = slug.split(/[^A-Za-z0-9]+/).filter(Boolean);
+  const name = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  return /^[0-9]/.test(name) ? `Section${name}` : name || "Section";
+}
+function propsInterfaceName(manifest) {
+  const base = manifest.exportName && IDENTIFIER_RE.test(manifest.exportName) ? manifest.exportName : pascalCase(manifest.section);
+  return `${base}Props`;
+}
+function generatePropsSource(schema, options) {
+  const fields = collectFields(schema);
+  const lines = [
+    `// Generated by @botlr/cli from the Botlr section definition "${options.section}".`,
+    "// Do not edit: the props schema lives in the dashboard, and `botlr pull` rewrites this file.",
+    ""
+  ];
+  if (fields.length === 0) {
+    lines.push("/** The definition has no props yet; define them in the dashboard and pull again. */");
+    lines.push(`export type ${options.interfaceName} = Record<string, unknown>;`);
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push(`export interface ${options.interfaceName} {`);
+  fields.forEach((field, index) => {
+    if (index > 0 && field.doc.length) lines.push("");
+    if (field.doc.length === 1) lines.push(`  /** ${field.doc[0]} */`);
+    else if (field.doc.length > 1) lines.push("  /**", ...field.doc.map((d) => `   * ${d}`), "   */");
+    lines.push(`  ${propertyKey(field.name)}${field.required ? "" : "?"}: ${field.type};`);
+  });
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+function propsPath(sectionsDir, name) {
+  return path6.join(sectionsDir, `${name}${PROPS_SUFFIX}`);
+}
+async function writePropsTypes(sectionsDir, manifest, schema) {
+  const interfaceName = propsInterfaceName(manifest);
+  const file = propsPath(sectionsDir, manifest.section);
+  const text = generatePropsSource(schema, { section: manifest.section, interfaceName });
+  try {
+    if (await readFile6(file, "utf8") === text) return { file, interfaceName, changed: false };
+  } catch {
+  }
+  await mkdir3(sectionsDir, { recursive: true });
+  await writeFile4(file, text, "utf8");
+  return { file, interfaceName, changed: true };
+}
+
+// src/drift.ts
+import { schemaFormat } from "@botlr/sdk";
+function manifestSchema(manifest) {
+  const schema = manifest.schema;
+  return schemaFormat(schema) ? schema : null;
+}
+function compareSchemas(manifest, definitionSchema) {
+  const code = manifestSchema(manifest);
+  if (!code) return null;
+  const codeKeys = new Set(schemaFieldNames(code));
+  const dashboardKeys = new Set(schemaFieldNames(definitionSchema));
+  const missingInDashboard = [...codeKeys].filter((k) => !dashboardKeys.has(k)).sort();
+  const missingInCode = [...dashboardKeys].filter((k) => !codeKeys.has(k)).sort();
+  if (missingInDashboard.length === 0 && missingInCode.length === 0) return null;
+  return { missingInDashboard, missingInCode };
+}
+function formatDriftWarning(name, drift) {
+  const lines = [`warning: props schema of '${name}' differs between the code and the dashboard`];
+  if (drift.missingInDashboard.length) {
+    lines.push(`  the code expects props the dashboard does not define: ${drift.missingInDashboard.join(", ")}`);
+  }
+  if (drift.missingInCode.length) {
+    lines.push(`  the dashboard defines props the code does not list: ${drift.missingInCode.join(", ")}`);
+  }
+  lines.push(`  the dashboard owns the schema; a code push never changes it. To resolve:`);
+  lines.push(`    botlr schema pull ${name}   takes the dashboard's schema into ${name}.botlr.json`);
+  lines.push(`    botlr schema push ${name}   sends the code's schema to the dashboard`);
+  return lines.join("\n");
+}
+
+// src/schema-diff.ts
+import { schemaFormat as schemaFormat2 } from "@botlr/sdk";
+function schemaKeys(schema) {
+  return [...new Set(schemaFieldNames(schema))];
+}
+function diffSchemaKeys(current, next) {
+  const currentKeys = new Set(schemaKeys(current));
+  const nextKeys = new Set(schemaKeys(next));
+  return {
+    added: [...nextKeys].filter((k) => !currentKeys.has(k)).sort(),
+    removed: [...currentKeys].filter((k) => !nextKeys.has(k)).sort(),
+    kept: [...nextKeys].filter((k) => currentKeys.has(k)).sort()
+  };
+}
+function previewSchemaPush(name, current, next, formats = {}) {
+  return {
+    name,
+    current,
+    currentFormat: formats.currentFormat ?? schemaFormat2(current),
+    next,
+    nextFormat: formats.nextFormat ?? schemaFormat2(next),
+    diff: diffSchemaKeys(current, next)
+  };
+}
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function formatName(format) {
+  return format ?? "unknown";
+}
+function formatSchemaDiff(preview) {
+  const { diff } = preview;
+  const header = `schema of '${preview.name}': dashboard has ${formatName(preview.currentFormat)} (${plural(schemaKeys(preview.current).length, "field")}), code has ${formatName(preview.nextFormat)} (${plural(schemaKeys(preview.next).length, "field")})`;
+  const lines = [header];
+  if (diff.added.length) lines.push(`  + added    ${diff.added.join(", ")}`);
+  if (diff.removed.length) lines.push(`  - removed  ${diff.removed.join(", ")}`);
+  lines.push(`  = kept     ${diff.kept.length ? diff.kept.join(", ") : "none"}`);
+  if (preview.currentFormat && preview.nextFormat && preview.currentFormat !== preview.nextFormat) {
+    lines.push(`  the formats differ: the push needs --force to replace ${preview.currentFormat} with ${preview.nextFormat}`);
+  }
+  if (!diff.added.length && !diff.removed.length) lines.push("  the field keys match; only field settings may change");
+  return lines.join("\n");
+}
+
 // src/client.ts
 import { createBotlrClient } from "@botlr/sdk";
 function clientFor(config, options = {}) {
@@ -402,16 +932,35 @@ async function pullSections(config, options) {
     });
     const { source } = response;
     const files = await writeSectionFiles(config.sectionsDir, source.files);
-    await writeManifest(config.sectionsDir, name, source.manifest);
-    const newEntry = {
+    const manifest = await writeManifestIfChanged(config.sectionsDir, name, source.manifest);
+    const registry = options.noRegistry ? void 0 : await registerSection(config.sectionsDir, config.registryFile, source.manifest);
+    let types;
+    let typesNotice;
+    if (config.types && !options.noTypes) {
+      if (response.definition) {
+        types = await writePropsTypes(config.sectionsDir, source.manifest, response.definition.schema);
+      } else {
+        typesNotice = "no section definition resolves for this section, no prop types written";
+      }
+    }
+    const fresh = {
       scope: source.scope,
       framework: source.framework,
       version: source.version,
       contentHash: source.contentHash,
       pulledAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    lock[name] = newEntry;
-    results.push({ name, scope: source.scope, version: source.version, files });
+    lock[name] = nextLockEntry(entry, fresh);
+    results.push({
+      name,
+      scope: source.scope,
+      version: source.version,
+      files,
+      manifestChanged: manifest.changed,
+      registry,
+      types,
+      typesNotice
+    });
   }
   await writeLock(config.root, lock);
   return results;
@@ -484,12 +1033,14 @@ async function pushSection(config, options) {
     contentHash: response.contentHash,
     pulledAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  const drift = compareSchemas(manifest, response.definition?.schema) ?? void 0;
   return {
     name,
     created: response.created,
     scope: response.scope,
     version: response.version,
-    contentHash: response.contentHash
+    contentHash: response.contentHash,
+    drift
   };
 }
 
@@ -506,10 +1057,20 @@ async function sectionStatuses(config, options = {}) {
   const names = options.names?.length ? options.names : await listManifests(config.sectionsDir);
   const lock = await readLock(config.root);
   let summaries = /* @__PURE__ */ new Map();
-  if (!options.offline) {
-    const listing = await clientFor(config).sections.list({ framework: config.framework });
+  const client = options.offline ? null : clientFor(config);
+  if (client) {
+    const listing = await client.sections.list({ framework: config.framework });
     summaries = new Map(listing.sections.map((s) => [s.name, s]));
   }
+  const driftFor = async (manifest) => {
+    if (!client || !manifestSchema(manifest) || !summaries.has(manifest.section)) return void 0;
+    try {
+      const pulled = await client.sections.pull(manifest.section, { framework: config.framework });
+      return compareSchemas(manifest, pulled.definition?.schema) ?? void 0;
+    } catch {
+      return void 0;
+    }
+  };
   const rows = [];
   for (const name of names) {
     const entry = lock[name];
@@ -523,7 +1084,8 @@ async function sectionStatuses(config, options = {}) {
         status: computeStatus({ localHash: localHash2, lock: entry, remote }),
         local: entry?.version ?? null,
         remote: remote?.version ?? null,
-        scope: entry?.scope ?? summary?.effective ?? "-"
+        scope: entry?.scope ?? summary?.effective ?? "-",
+        drift: await driftFor(manifest)
       });
     } catch (error) {
       rows.push({
@@ -541,12 +1103,16 @@ async function sectionStatuses(config, options = {}) {
 
 // src/commands/init.ts
 async function initSections(config, options = {}) {
-  if (!await hasRegistry(config.sectionsDir)) {
-    throw new Error(`No ${REGISTRY_FILE} in ${config.sectionsDir}; sections init reads the registry map to find components`);
+  if (!await hasRegistry(config.sectionsDir, config.registryFile)) {
+    throw new Error(`No ${config.registryFile}; sections init reads the registry map to find components`);
   }
   const existing = new Set(await listManifests(config.sectionsDir));
   const npmVersions = await readNpmVersions(config.sectionsDir);
-  const derived = await deriveManifests(config.sectionsDir, { framework: config.framework, npmVersions });
+  const derived = await deriveManifests(config.sectionsDir, {
+    framework: config.framework,
+    npmVersions,
+    registryFile: config.registryFile
+  });
   const results = [];
   for (const { name, manifest, entryFile } of derived) {
     const skip = existing.has(name) && !options.force;
@@ -558,44 +1124,176 @@ async function initSections(config, options = {}) {
   }
   return results;
 }
+
+// src/commands/schema.ts
+import { BotlrError, BotlrSchemaFormatConflictError, botlrErrorMessage } from "@botlr/sdk";
+function isNotFound(error) {
+  return error instanceof BotlrError && error.status === 404;
+}
+async function pullSchemas(config, options) {
+  const client = clientFor(config);
+  const names = options.all ? await listManifests(config.sectionsDir) : options.names;
+  const results = [];
+  for (const name of names) {
+    let manifest;
+    try {
+      manifest = await readManifest(config.sectionsDir, name);
+    } catch (error) {
+      results.push({ name, changed: false, file: "", error: error.message });
+      continue;
+    }
+    let definition;
+    try {
+      definition = (await client.sections.getSchema(name)).definition;
+    } catch (error) {
+      if (!isNotFound(error)) throw error;
+      results.push({ name, changed: false, file: "", error: `the app has no section type '${name}' (botlr push ${name} --create adds one)` });
+      continue;
+    }
+    const updated = { ...manifest, schema: definition.schema };
+    const written = await writeManifestIfChanged(config.sectionsDir, name, updated);
+    const types = config.types && !options.noTypes ? await writePropsTypes(config.sectionsDir, manifest, definition.schema) : void 0;
+    results.push({ name, changed: written.changed, file: written.file, format: definition.format, types });
+  }
+  return results;
+}
+var SchemaFormatConflict = class extends Error {
+  constructor(sectionName, currentFormat, newFormat, message) {
+    super(message ?? `the schema of '${sectionName}' is stored as ${currentFormat}, the manifest's is ${newFormat}`);
+    this.sectionName = sectionName;
+    this.currentFormat = currentFormat;
+    this.newFormat = newFormat;
+    this.name = "SchemaFormatConflict";
+  }
+  sectionName;
+  currentFormat;
+  newFormat;
+};
+var SchemaRejected = class extends Error {
+  constructor(sectionName, message) {
+    super(message);
+    this.sectionName = sectionName;
+    this.name = "SchemaRejected";
+  }
+  sectionName;
+};
+async function pushSchema(config, options) {
+  const client = clientFor(config, { needPersonalToken: true });
+  const { name } = options;
+  const manifest = await readManifest(config.sectionsDir, name);
+  const next = manifest.schema;
+  if (!next || typeof next !== "object" || Array.isArray(next)) {
+    throw new ManifestError(
+      `${name}.botlr.json has no 'schema' object to push; add one, or run 'botlr schema pull ${name}' to take the dashboard's`
+    );
+  }
+  let current;
+  try {
+    current = (await client.sections.getSchema(name)).definition;
+  } catch (error) {
+    if (!isNotFound(error)) throw error;
+    throw new ManifestError(`the app has no section type '${name}'; push the code first with 'botlr push ${name} --create'`);
+  }
+  const preview = previewSchemaPush(name, current.schema, next, { currentFormat: current.format });
+  if (options.confirm && !await options.confirm(preview)) {
+    return { name, preview, pushed: false };
+  }
+  let response;
+  try {
+    response = await client.sections.putSchema(name, { schema: next, force: options.force ?? false });
+  } catch (error) {
+    if (error instanceof BotlrSchemaFormatConflictError) {
+      throw new SchemaFormatConflict(name, error.currentFormat, error.newFormat, botlrErrorMessage(error));
+    }
+    if (error instanceof BotlrError && error.status === 422) {
+      throw new SchemaRejected(name, botlrErrorMessage(error) ?? "the server rejected the schema (422)");
+    }
+    throw error;
+  }
+  const types = config.types && !options.noTypes ? await writePropsTypes(config.sectionsDir, manifest, response.definition.schema) : void 0;
+  return {
+    name,
+    preview,
+    pushed: true,
+    changed: response.changed,
+    previousFormat: response.previousFormat,
+    format: response.definition.format,
+    types
+  };
+}
 export {
   CONFIG_FILE,
   ConfigError,
   DEFAULT_FRAMEWORK,
+  DEFAULT_REGISTRY_FILE,
   DEFAULT_SECTIONS_DIR,
   LOCK_DIR,
   LOCK_FILE,
+  MANIFEST_KEY_ORDER,
   MANIFEST_SUFFIX,
   ManifestError,
+  PROPS_SUFFIX,
   REGISTRY_FILE,
+  SchemaFormatConflict,
+  SchemaRejected,
+  addRegistryEntry,
   clientFor,
+  collectDslFields,
+  collectFields,
+  collectFormBuilderFields,
+  compareSchemas,
   computeStatus,
   deriveManifests,
+  diffSchemaKeys,
   findConfigFile,
+  formatDriftWarning,
+  formatManifest,
+  formatSchemaDiff,
+  generatePropsSource,
   hasRegistry,
+  importPathFor,
   initSections,
   listManifests,
   listSections,
   loadConfig,
   lockPath,
   manifestPath,
+  manifestSchema,
+  manifestsEqual,
+  nextLockEntry,
+  normalizeManifest,
+  optionUnion,
   parseDefinition,
   parseImports,
   parseRegistry,
+  parseZodSchema,
+  pascalCase,
+  previewSchemaPush,
+  propsInterfaceName,
+  propsPath,
+  pullSchemas,
   pullSections,
+  pushSchema,
   pushSection,
   readConfigFile,
   readLock,
   readManifest,
   readNpmVersions,
   readSectionFiles,
+  registerSection,
   remoteForLock,
   safeJoin,
+  schemaFieldNames,
+  schemaKeys,
   sectionStatuses,
+  tsTypeForField,
   updateLock,
   validateManifest,
   writeLock,
   writeManifest,
-  writeSectionFiles
+  writeManifestIfChanged,
+  writePropsTypes,
+  writeSectionFiles,
+  zodFieldToSchemaField
 };
 //# sourceMappingURL=index.js.map