@otl-core/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+
+// src/api/client.ts
+function buildUrl(config, path5) {
+  const base = config.apiUrl.replace(/\/+$/, "");
+  return `${base}/api/v1/public/deployments/${encodeURIComponent(config.deploymentId)}${path5}`;
+}
+function authHeaders(config) {
+  return {
+    Authorization: `Bearer ${config.accessToken}`,
+    Accept: "application/json"
+  };
+}
+async function fetchJson(url, headers) {
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `API request failed (${response.status} ${response.statusText}): ${body}`
+    );
+  }
+  return response.json();
+}
+async function fetchBlockSchemas(config) {
+  const url = buildUrl(config, "/schemas/blocks");
+  const result = await fetchJson(
+    url,
+    authHeaders(config)
+  );
+  return result.data.schemas;
+}
+async function findBlockSchemaByType(config, typeName) {
+  const schemas = await fetchBlockSchemas(config);
+  return schemas.find((s) => s.type === typeName);
+}
+async function fetchSectionSchemas(config) {
+  const url = buildUrl(config, "/schemas/sections");
+  const result = await fetchJson(
+    url,
+    authHeaders(config)
+  );
+  return result.data;
+}
+async function findSectionSchemaByType(config, typeName) {
+  const schemas = await fetchSectionSchemas(config);
+  return schemas.find((s) => s.type === typeName);
+}
+
+// src/utils/naming.ts
+function kebabToPascal(kebab) {
+  return kebab.split("-").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function fieldIdToCamel(id) {
+  return id.replace(/[-_]([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+// src/codegen/type-mapper.ts
+function createEmptyImports() {
+  return {
+    ColorReference: false,
+    MediaReference: false,
+    ResponsiveValue: false,
+    BlockInstance: false,
+    LocalizedString: false
+  };
+}
+function buildTypeImportLine(imports) {
+  const needed = [];
+  if (imports.ColorReference) needed.push("ColorReference");
+  if (imports.MediaReference) needed.push("MediaReference");
+  if (imports.ResponsiveValue) needed.push("ResponsiveValue");
+  if (imports.BlockInstance) needed.push("BlockInstance");
+  if (imports.LocalizedString) needed.push("LocalizedString");
+  if (needed.length === 0) {
+    return null;
+  }
+  return `import type { ${needed.join(", ")} } from "@otl-core/cms-types";`;
+}
+var SIMPLE_TYPE_MAP = {
+  text: "string",
+  textarea: "string",
+  url: "string",
+  markdown: "string",
+  html: "string",
+  code: "string",
+  richtext: "string",
+  date: "string",
+  number: "number",
+  boolean: "boolean",
+  color: "string",
+  "form-selector": "string",
+  "form-page": "string",
+  json: "Record<string, unknown>",
+  object: "Record<string, unknown>",
+  array: "unknown[]",
+  "container-behavior": '"boxed" | "edged" | "ignore"'
+};
+function resolveFieldType(field, imports) {
+  const simple = SIMPLE_TYPE_MAP[field.type];
+  if (simple !== void 0) {
+    return simple;
+  }
+  switch (field.type) {
+    // Select can be single or multi
+    case "select":
+      return field.multiple ? "string[]" : "string";
+    // Theme color types
+    case "theme-color":
+    case "theme-background-color":
+    case "theme-foreground-color":
+      imports.ColorReference = true;
+      return "ColorReference";
+    // Image / media
+    case "image":
+      imports.MediaReference = true;
+      return "MediaReference";
+    // Responsive value types
+    case "spacing":
+    case "css-value":
+    case "columns":
+      imports.ResponsiveValue = true;
+      return "ResponsiveValue<string>";
+    // Blocks
+    case "blocks":
+      imports.BlockInstance = true;
+      return "BlockInstance[]";
+    // Localized text
+    case "localized-text":
+      imports.LocalizedString = true;
+      return "LocalizedString";
+    // Group -- will be handled by the interface generator to produce a nested
+    // interface. At the type level we return the interface name.
+    case "group":
+      return "__GROUP__";
+    default:
+      return "unknown";
+  }
+}
+function generateInterface(interfaceName, fields) {
+  const imports = createEmptyImports();
+  const extraInterfaces = [];
+  const lines = buildInterfaceLines(
+    interfaceName,
+    fields,
+    imports,
+    extraInterfaces
+  );
+  const mainInterface = [`interface ${interfaceName} {`, ...lines, "}"].join(
+    "\n"
+  );
+  const declarations = [...extraInterfaces, mainInterface].join("\n\n");
+  return { name: interfaceName, declarations, imports };
+}
+function buildInterfaceLines(parentName, fields, imports, extraInterfaces) {
+  const lines = [];
+  for (const field of fields) {
+    const camelId = fieldIdToCamel(field.id);
+    let tsType = resolveFieldType(field, imports);
+    if (tsType === "__GROUP__" && field.fields && field.fields.length > 0) {
+      const nestedName = parentName + kebabToPascal(field.id);
+      const nestedLines = buildInterfaceLines(
+        nestedName,
+        field.fields,
+        imports,
+        extraInterfaces
+      );
+      const nestedDecl = [
+        `interface ${nestedName} {`,
+        ...nestedLines,
+        "}"
+      ].join("\n");
+      extraInterfaces.push(nestedDecl);
+      tsType = nestedName;
+    } else if (tsType === "__GROUP__") {
+      tsType = "Record<string, unknown>";
+    }
+    if (field.description) {
+      lines.push(`  /** ${field.description} */`);
+    }
+    lines.push(`  ${camelId}?: ${tsType};`);
+  }
+  return lines;
+}
+
+// src/codegen/generate-block.ts
+function generateBlockComponent(typeName, fields) {
+  const pascal = kebabToPascal(typeName);
+  const configName = `${pascal}Config`;
+  const componentName = `${pascal}Block`;
+  const result = generateInterface(configName, fields);
+  const importLines = [];
+  const typeImportLine = buildTypeImportLine(result.imports);
+  if (typeImportLine) {
+    const typesInBraces = typeImportLine.replace("import type { ", "").replace(' } from "@otl-core/cms-types";', "");
+    importLines.push(
+      `import type { BlockComponentProps, ${typesInBraces} } from "@otl-core/cms-types";`
+    );
+  } else {
+    importLines.push(
+      'import type { BlockComponentProps } from "@otl-core/cms-types";'
+    );
+  }
+  const fieldIds = fields.map((f) => fieldIdToCamel(f.id)).filter((id) => id.length > 0);
+  const destructuring = fieldIds.length > 0 ? `  const { ${fieldIds.join(", ")} } = config;
+` : "";
+  const parts = [
+    importLines.join("\n"),
+    "",
+    result.declarations,
+    "",
+    `export function ${componentName}({ config }: BlockComponentProps<${configName}>) {`,
+    destructuring,
+    "  return (",
+    "    <div>",
+    `      {/* TODO: Implement ${typeName} block */}`,
+    "    </div>",
+    "  );",
+    "}",
+    ""
+  ];
+  return parts.join("\n");
+}
+
+// src/codegen/generate-section.ts
+function generateSectionComponent(typeName, fields) {
+  const pascal = kebabToPascal(typeName);
+  const configName = `${pascal}Config`;
+  const componentName = `${pascal}Section`;
+  const result = generateInterface(configName, fields);
+  const importLines = [];
+  const typeImportLine = buildTypeImportLine(result.imports);
+  if (typeImportLine) {
+    const typesInBraces = typeImportLine.replace("import type { ", "").replace(' } from "@otl-core/cms-types";', "");
+    importLines.push(
+      `import type { SectionComponentProps, ${typesInBraces} } from "@otl-core/cms-types";`
+    );
+  } else {
+    importLines.push(
+      'import type { SectionComponentProps } from "@otl-core/cms-types";'
+    );
+  }
+  const fieldIds = fields.map((f) => fieldIdToCamel(f.id)).filter((id) => id.length > 0);
+  const destructuring = fieldIds.length > 0 ? `  const { ${fieldIds.join(", ")} } = config;
+` : "";
+  const parts = [
+    importLines.join("\n"),
+    "",
+    result.declarations,
+    "",
+    `export function ${componentName}({ config }: SectionComponentProps<${configName}>) {`,
+    destructuring,
+    "  return (",
+    "    <div>",
+    `      {/* TODO: Implement ${typeName} section */}`,
+    "    </div>",
+    "  );",
+    "}",
+    ""
+  ];
+  return parts.join("\n");
+}
+
+// src/codegen/registry-updater.ts
+import * as fs from "fs";
+function addToBlockRegistry(registryPath, typeName) {
+  const pascal = kebabToPascal(typeName);
+  const componentName = `${pascal}Block`;
+  const importPath = `@/components/blocks/${typeName}`;
+  const importLine = `import { ${componentName} } from "${importPath}";`;
+  const registerLine = `blockRegistry.register("${typeName}", ${componentName});`;
+  updateRegistryFile(registryPath, importLine, registerLine);
+}
+function addToSectionRegistry(registryPath, typeName) {
+  const pascal = kebabToPascal(typeName);
+  const componentName = `${pascal}Section`;
+  const importPath = `@/components/sections/${typeName}`;
+  const importLine = `import { ${componentName} } from "${importPath}";`;
+  const registerLine = `sectionRegistry.register("${typeName}", ${componentName});`;
+  updateRegistryFile(registryPath, importLine, registerLine);
+}
+function updateRegistryFile(filePath, importLine, registerLine) {
+  let content = fs.readFileSync(filePath, "utf-8");
+  if (content.includes(registerLine)) {
+    return;
+  }
+  const importRegex = /^import .+$/gm;
+  let lastImportMatch = null;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    lastImportMatch = match;
+  }
+  if (lastImportMatch) {
+    const insertPos = lastImportMatch.index + lastImportMatch[0].length;
+    content = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+  } else {
+    content = importLine + "\n" + content;
+  }
+  const customCommentIndex = content.indexOf("/**\n * Custom ");
+  if (customCommentIndex !== -1) {
+    content = content.slice(0, customCommentIndex) + registerLine + "\n\n" + content.slice(customCommentIndex);
+  } else {
+    content = content.trimEnd() + "\n" + registerLine + "\n";
+  }
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+// src/utils/env.ts
+import * as dotenv from "dotenv";
+import * as fs2 from "fs";
+import * as path from "path";
+function loadConfig() {
+  const envLocalPath = path.resolve(process.cwd(), ".env.local");
+  let fileEnv = {};
+  if (fs2.existsSync(envLocalPath)) {
+    const parsed = dotenv.parse(fs2.readFileSync(envLocalPath, "utf-8"));
+    fileEnv = parsed;
+  }
+  const deploymentId = fileEnv["DEPLOYMENT_ID"] || process.env["DEPLOYMENT_ID"] || "";
+  const accessToken = fileEnv["DEPLOYMENT_ACCESS_TOKEN"] || process.env["DEPLOYMENT_ACCESS_TOKEN"] || "";
+  const apiUrl = fileEnv["API_URL"] || process.env["API_URL"] || "http://localhost:8080";
+  if (!deploymentId || !accessToken) {
+    console.error(
+      "Error: Missing DEPLOYMENT_ID and/or DEPLOYMENT_ACCESS_TOKEN."
+    );
+    console.error(
+      "Run 'npx @otl-core/cli init' to configure your environment."
+    );
+    process.exit(1);
+  }
+  return { deploymentId, accessToken, apiUrl };
+}
+
+// src/utils/project.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+var ENGINE_MARKERS = [
+  "@otl-core/block-registry",
+  "@otl-core/section-registry"
+];
+function readPackageJson(dir) {
+  const filePath = path2.join(dir, "package.json");
+  if (!fs3.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isEngineProject(dir) {
+  const pkg = readPackageJson(dir);
+  if (!pkg) {
+    return false;
+  }
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  return ENGINE_MARKERS.some((marker) => marker in allDeps);
+}
+function requireEngineProject() {
+  let current = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    if (isEngineProject(current)) {
+      return {
+        root: current,
+        blocksDir: path2.join(current, "src", "components", "blocks"),
+        sectionsDir: path2.join(current, "src", "components", "sections"),
+        blockRegistryFile: path2.join(
+          current,
+          "src",
+          "lib",
+          "registries",
+          "block-registry.ts"
+        ),
+        sectionRegistryFile: path2.join(
+          current,
+          "src",
+          "lib",
+          "registries",
+          "section-registry.ts"
+        )
+      };
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  console.error("Error: Not in a OTL engine project.");
+  console.error("Could not find a package.json with @otl-core/ dependencies.");
+  console.error("Run this command from your engine project root.");
+  process.exit(1);
+}
+
+// src/commands/add.ts
+function registerAddCommands(program2) {
+  const add = program2.command("add").description("Generate a component from a schema definition");
+  add.command("block <name>").description("Generate a block component from its schema").option("--force", "Overwrite existing files").action(async (name, opts) => {
+    try {
+      const paths = requireEngineProject();
+      const config = loadConfig();
+      const schema = await findBlockSchemaByType(config, name);
+      if (!schema) {
+        console.error(`Error: No block schema found with type "${name}".`);
+        console.error(
+          "Run 'npx @otl-core/cli list blocks' to see available schemas."
+        );
+        process.exit(1);
+      }
+      const outputFile = path3.join(paths.blocksDir, `${name}.tsx`);
+      if (fs4.existsSync(outputFile) && !opts.force) {
+        console.error(
+          `Error: ${path3.relative(paths.root, outputFile)} already exists.`
+        );
+        console.error("Use --force to overwrite.");
+        process.exit(1);
+      }
+      const content = generateBlockComponent(name, schema.fields);
+      fs4.mkdirSync(path3.dirname(outputFile), { recursive: true });
+      fs4.writeFileSync(outputFile, content, "utf-8");
+      const relPath = path3.relative(paths.root, outputFile);
+      console.log(`Created ${relPath}`);
+      if (fs4.existsSync(paths.blockRegistryFile)) {
+        addToBlockRegistry(paths.blockRegistryFile, name);
+        console.log(
+          `Updated ${path3.relative(paths.root, paths.blockRegistryFile)}`
+        );
+      }
+      console.log("");
+      console.log(`Next: implement your component in ${relPath}`);
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+  add.command("section <name>").description("Generate a section component from its schema").option("--force", "Overwrite existing files").action(async (name, opts) => {
+    try {
+      const paths = requireEngineProject();
+      const config = loadConfig();
+      const schema = await findSectionSchemaByType(config, name);
+      if (!schema) {
+        console.error(`Error: No section schema found with type "${name}".`);
+        console.error(
+          "Run 'npx @otl-core/cli list sections' to see available schemas."
+        );
+        process.exit(1);
+      }
+      const outputFile = path3.join(paths.sectionsDir, `${name}.tsx`);
+      if (fs4.existsSync(outputFile) && !opts.force) {
+        console.error(
+          `Error: ${path3.relative(paths.root, outputFile)} already exists.`
+        );
+        console.error("Use --force to overwrite.");
+        process.exit(1);
+      }
+      const content = generateSectionComponent(name, schema.fields);
+      fs4.mkdirSync(path3.dirname(outputFile), { recursive: true });
+      fs4.writeFileSync(outputFile, content, "utf-8");
+      const relPath = path3.relative(paths.root, outputFile);
+      console.log(`Created ${relPath}`);
+      if (fs4.existsSync(paths.sectionRegistryFile)) {
+        addToSectionRegistry(paths.sectionRegistryFile, name);
+        console.log(
+          `Updated ${path3.relative(paths.root, paths.sectionRegistryFile)}`
+        );
+      }
+      console.log("");
+      console.log(`Next: implement your component in ${relPath}`);
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+import * as readline from "readline";
+function registerInitCommand(program2) {
+  program2.command("init").description("Configure deployment credentials in .env.local").action(async () => {
+    try {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const ask = (question) => new Promise((resolve3) => {
+        rl.question(question, (answer) => resolve3(answer.trim()));
+      });
+      console.log("OTL CMS -- Engine Configuration");
+      console.log("");
+      const deploymentId = await ask("Deployment ID: ");
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required.");
+        rl.close();
+        process.exit(1);
+      }
+      const accessToken = await ask("Deployment Access Token: ");
+      if (!accessToken) {
+        console.error("Error: Access token is required.");
+        rl.close();
+        process.exit(1);
+      }
+      const apiUrlInput = await ask("API URL [http://localhost:8080]: ");
+      const apiUrl = apiUrlInput || "http://localhost:8080";
+      rl.close();
+      const envPath = path4.resolve(process.cwd(), ".env.local");
+      let content = "";
+      if (fs5.existsSync(envPath)) {
+        content = fs5.readFileSync(envPath, "utf-8");
+        content = upsertEnvVar(content, "DEPLOYMENT_ID", deploymentId);
+        content = upsertEnvVar(
+          content,
+          "DEPLOYMENT_ACCESS_TOKEN",
+          accessToken
+        );
+        content = upsertEnvVar(content, "API_URL", apiUrl);
+      } else {
+        content = [
+          "# OTL CMS Engine Configuration",
+          `DEPLOYMENT_ID=${deploymentId}`,
+          `DEPLOYMENT_ACCESS_TOKEN=${accessToken}`,
+          `API_URL=${apiUrl}`,
+          ""
+        ].join("\n");
+      }
+      fs5.writeFileSync(envPath, content, "utf-8");
+      console.log("");
+      console.log("Written to .env.local");
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+function upsertEnvVar(content, key, value) {
+  const regex = new RegExp(`^${key}=.*$`, "m");
+  if (regex.test(content)) {
+    return content.replace(regex, `${key}=${value}`);
+  }
+  const base = content.endsWith("\n") ? content : content + "\n";
+  return base + `${key}=${value}
+`;
+}
+
+// src/commands/list.ts
+function registerListCommands(program2) {
+  const list = program2.command("list").description("List available schemas for the deployment");
+  list.command("blocks").description("List all block schemas").action(async () => {
+    try {
+      const config = loadConfig();
+      const schemas = await fetchBlockSchemas(config);
+      if (schemas.length === 0) {
+        console.log("No block schemas found for this deployment.");
+        return;
+      }
+      const typeCol = 24;
+      const nameCol = 28;
+      const fieldsCol = 8;
+      console.log(
+        padRight("TYPE", typeCol) + padRight("NAME", nameCol) + padRight("FIELDS", fieldsCol)
+      );
+      console.log("-".repeat(typeCol + nameCol + fieldsCol));
+      for (const schema of schemas) {
+        const fieldCount = schema.fields ? schema.fields.length : 0;
+        console.log(
+          padRight(schema.type, typeCol) + padRight(schema.name, nameCol) + String(fieldCount)
+        );
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+  list.command("sections").description("List all section schemas").action(async () => {
+    try {
+      const config = loadConfig();
+      const schemas = await fetchSectionSchemas(config);
+      if (schemas.length === 0) {
+        console.log("No section schemas found for this deployment.");
+        return;
+      }
+      const typeCol = 24;
+      const nameCol = 28;
+      const fieldsCol = 8;
+      console.log(
+        padRight("TYPE", typeCol) + padRight("NAME", nameCol) + padRight("FIELDS", fieldsCol)
+      );
+      console.log("-".repeat(typeCol + nameCol + fieldsCol));
+      for (const schema of schemas) {
+        const fieldCount = schema.fields ? schema.fields.length : 0;
+        console.log(
+          padRight(schema.type, typeCol) + padRight(schema.name, nameCol) + String(fieldCount)
+        );
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+function padRight(str, width) {
+  if (str.length >= width) {
+    return str + "  ";
+  }
+  return str + " ".repeat(width - str.length);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("otl-cli").description("OTL CMS CLI -- scaffold and manage engine components").version("0.1.0");
+registerAddCommands(program);
+registerListCommands(program);
+registerInitCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map