@stormycms/cli 0.0.10

package/dist/index.js

@@ -0,0 +1,408 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  detectFrameworkFromDeps: () => detectFrameworkFromDeps,
+  init: () => init,
+  loadConfig: () => loadConfig,
+  pluginRegistry: () => pluginRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.16_tsx@4.23.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/plugin-registry.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var PluginRegistry = class {
+  #frameworkPlugins = /* @__PURE__ */ new Map();
+  #customPlugins = /* @__PURE__ */ new Map();
+  #api;
+  constructor() {
+    this.#api = this.#createPluginAPI();
+  }
+  #createPluginAPI() {
+    return {
+      registerParser: (extensions, _parser) => {
+        console.log(`Registered parser for extensions: ${extensions.join(", ")}`);
+      },
+      registerFieldType: (typeName, fieldType) => {
+        console.log(`Registered field type mapping: ${typeName} -> ${fieldType}`);
+      },
+      onBeforeGenerate: (_callback) => {
+      },
+      onAfterGenerate: (_callback) => {
+      }
+    };
+  }
+  /** Register a framework plugin */
+  registerFrameworkPlugin(plugin) {
+    this.#frameworkPlugins.set(plugin.name, plugin);
+  }
+  /** Register a custom plugin */
+  registerCustomPlugin(plugin) {
+    this.#customPlugins.set(plugin.name, plugin);
+    plugin.setup(this.#api);
+  }
+  /** Get a framework plugin by name */
+  getFrameworkPlugin(name) {
+    return this.#frameworkPlugins.get(name);
+  }
+  /** List all registered framework plugins */
+  listFrameworkPlugins() {
+    return Array.from(this.#frameworkPlugins.keys());
+  }
+  /** Auto-detect framework from project dependencies */
+  async detectFramework(cwd) {
+    for (const [name, plugin] of this.#frameworkPlugins) {
+      try {
+        const detected = await plugin.detect(cwd);
+        if (detected) {
+          return name;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  /** Load plugins from stormy.config.ts */
+  async loadConfigPlugins(cwd) {
+    const configPath = import_node_path.default.join(cwd, "stormy.config.ts");
+    if (!import_node_fs.default.existsSync(configPath)) {
+      return;
+    }
+    try {
+      const configModule = await import(configPath);
+      const config = configModule.default || configModule;
+      if (config.plugins) {
+        for (const pluginPath of config.plugins) {
+          const resolvedPath = import_node_path.default.resolve(cwd, pluginPath);
+          if (import_node_fs.default.existsSync(resolvedPath)) {
+            const pluginModule = await import(resolvedPath);
+            const plugin = pluginModule.default || pluginModule;
+            if (this.#isValidCustomPlugin(plugin)) {
+              this.registerCustomPlugin(plugin);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load stormy.config.ts:", error);
+    }
+  }
+  #isValidCustomPlugin(plugin) {
+    return typeof plugin === "object" && plugin !== null && "name" in plugin && "setup" in plugin && typeof plugin.setup === "function";
+  }
+};
+var pluginRegistry = new PluginRegistry();
+
+// src/config.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var DEFAULT_CONFIG = {
+  components: "./src/components",
+  output: "./componentschema.ts"
+};
+async function loadConfig(cwd) {
+  let config = {};
+  const configPath = import_node_path2.default.join(cwd, "stormy.config.ts");
+  if (import_node_fs2.default.existsSync(configPath)) {
+    try {
+      const configModule = await import(configPath);
+      config = configModule.default || configModule;
+    } catch (error) {
+      console.warn("Failed to load stormy.config.ts:", error);
+    }
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+}
+async function detectFrameworkFromDeps(cwd) {
+  const packageJsonPath = import_node_path2.default.join(cwd, "package.json");
+  if (!import_node_fs2.default.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = import_node_fs2.default.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["vue"] || deps["@vue/runtime-core"]) return "vue";
+    if (deps["svelte"] || deps["svelte-check"]) return "svelte";
+    if (deps["solid-js"]) return "solid";
+    if (deps["react"] || deps["react-dom"]) return "react";
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/init.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_node_url = require("url");
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var import_adm_zip = __toESM(require("adm-zip"));
+var import_prompts = __toESM(require("prompts"));
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+var __dirname = import_node_path3.default.dirname(__filename2);
+var DEFAULT_PROJECT_NAME = "my-stormy-site";
+var filesToReplaceProjectName = ["package.json", "package-lock.json", "pnpm-lock.yaml", "README.md"];
+var envFiles = ["apps/admin/.env.example", "apps/site/.env.example"];
+var placeholderPattern = /your-[\w-]+-here/;
+async function init(options) {
+  const projectName = await promptProjectName(options.projectName);
+  const targetDir = options.target ? import_node_path3.default.resolve(options.target) : await promptTargetDirectory(projectName);
+  if (import_node_fs3.default.existsSync(targetDir) && import_node_fs3.default.readdirSync(targetDir).length > 0) {
+    throw new Error(`Target directory is not empty: ${targetDir}`);
+  }
+  import_node_fs3.default.mkdirSync(targetDir, { recursive: true });
+  console.log("Extracting boilerplate...");
+  extractBoilerplate(targetDir);
+  console.log("Applying project name...");
+  replaceProjectName(targetDir, projectName);
+  const envAnswers = await promptEnvValues(targetDir, options.skipEnv);
+  await generateEnvFiles(targetDir, envAnswers);
+  console.log("Initializing git repository...");
+  await initializeGitRepository(targetDir);
+  if (!options.skipInstall) {
+    console.log("Installing dependencies...");
+    await runPnpmInstall(targetDir);
+  }
+  console.log("\n\u2705 Project initialized successfully!");
+  console.log(`
+Location: ${targetDir}`);
+  console.log(`Project name: ${projectName}`);
+  console.log("\nNext steps:");
+  const relativeTarget = import_node_path3.default.relative(process.cwd(), targetDir);
+  const cdTarget = relativeTarget.startsWith("..") || import_node_path3.default.isAbsolute(targetDir) ? targetDir : relativeTarget || ".";
+  console.log(`  cd ${cdTarget}`);
+  if (options.skipInstall) console.log("  pnpm install");
+  console.log("  pnpm dev");
+  console.log("\nThe public site runs at http://localhost:3000");
+  console.log("The admin runs at http://localhost:4000");
+  console.log("\nConfigure your Stormy CMS credentials in the generated .env files if you skipped them.");
+}
+function findBoilerplateZip() {
+  const candidates = [import_node_path3.default.resolve(__dirname, "../boilerplate.zip"), import_node_path3.default.resolve(__dirname, "../../boilerplate.zip")];
+  for (const candidate of candidates) {
+    if (import_node_fs3.default.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("Boilerplate package not found.");
+}
+function extractBoilerplate(targetDir) {
+  const zipPath = findBoilerplateZip();
+  const zip = new import_adm_zip.default(zipPath);
+  zip.extractAllTo(targetDir, true);
+}
+function isProjectNameSafe(name) {
+  return name.length <= 214 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
+}
+async function promptProjectName(providedName) {
+  if (providedName) {
+    if (!isProjectNameSafe(providedName)) {
+      throw new Error("Project name must be lowercase kebab-case (for example, `my-stormy-site`).");
+    }
+    return providedName;
+  }
+  const response = await (0, import_prompts.default)({
+    type: "text",
+    name: "projectName",
+    message: "Project name",
+    initial: DEFAULT_PROJECT_NAME,
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Project name is required";
+      }
+      if (!isProjectNameSafe(value)) {
+        return "Use lowercase letters, numbers, and single hyphens";
+      }
+      return true;
+    }
+  });
+  if (!response.projectName) {
+    throw new Error("Project name is required.");
+  }
+  return response.projectName;
+}
+async function promptTargetDirectory(projectName) {
+  const initial = `./${projectName}`;
+  const response = await (0, import_prompts.default)({
+    type: "text",
+    name: "target",
+    message: "Project directory",
+    initial,
+    validate: (value) => value?.trim() ? true : "Project directory is required"
+  });
+  if (!response.target) throw new Error("Project directory is required.");
+  return import_node_path3.default.resolve(response.target);
+}
+function replaceProjectName(targetDir, projectName) {
+  for (const relativePath of filesToReplaceProjectName) {
+    const filePath = import_node_path3.default.join(targetDir, relativePath);
+    if (!import_node_fs3.default.existsSync(filePath)) {
+      continue;
+    }
+    const content = import_node_fs3.default.readFileSync(filePath, "utf-8");
+    const updated = content.replaceAll("stormy-cms-nextjs-boilerplate", projectName);
+    import_node_fs3.default.writeFileSync(filePath, updated, "utf-8");
+  }
+}
+function parseEnvFile(filePath) {
+  const content = import_node_fs3.default.readFileSync(filePath, "utf-8");
+  const values = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    values[key] = value;
+  }
+  return values;
+}
+function isPlaceholder(value) {
+  return placeholderPattern.test(value) || value === "";
+}
+function isDefaultUrl(value) {
+  return value.startsWith("http://localhost");
+}
+function groupMissingKeys(values) {
+  return Object.entries(values).filter(([_key, value]) => !isDefaultUrl(value) && isPlaceholder(value)).map(([key]) => key);
+}
+async function promptEnvValues(targetDir, skipEnv) {
+  const answers = {};
+  if (skipEnv) {
+    return answers;
+  }
+  const skipResponse = await (0, import_prompts.default)({
+    type: "confirm",
+    name: "skip",
+    message: "Skip environment variable prompts and create .env files from examples?",
+    initial: false
+  });
+  if (skipResponse.skip) {
+    return answers;
+  }
+  const missingKeyFiles = /* @__PURE__ */ new Map();
+  for (const relativePath of envFiles) {
+    const examplePath = import_node_path3.default.join(targetDir, relativePath);
+    if (!import_node_fs3.default.existsSync(examplePath)) continue;
+    const values = parseEnvFile(examplePath);
+    for (const key of groupMissingKeys(values)) {
+      missingKeyFiles.set(key, [...missingKeyFiles.get(key) ?? [], relativePath]);
+    }
+  }
+  for (const [key, relativePaths] of missingKeyFiles) {
+    const response = await (0, import_prompts.default)({
+      type: key.includes("SECRET") ? "password" : "text",
+      name: "value",
+      message: `${key} (${relativePaths.join(", ")})`
+    });
+    if (!response.value) continue;
+    for (const relativePath of relativePaths) {
+      answers[relativePath] ??= {};
+      answers[relativePath][key] = response.value;
+    }
+  }
+  return answers;
+}
+async function initializeGitRepository(targetDir) {
+  const gitDir = import_node_path3.default.join(targetDir, ".git");
+  if (import_node_fs3.default.existsSync(gitDir)) {
+    return;
+  }
+  try {
+    await execFileAsync("git", ["init"], { cwd: targetDir });
+    await execFileAsync("git", ["add", "."], { cwd: targetDir });
+    await execFileAsync("git", ["commit", "-m", "Initial commit"], { cwd: targetDir });
+  } catch (error) {
+    console.warn(`Warning: could not initialize git repository: ${error}`);
+  }
+}
+async function generateEnvFiles(targetDir, answers) {
+  for (const relativePath of envFiles) {
+    const examplePath = import_node_path3.default.join(targetDir, relativePath);
+    if (!import_node_fs3.default.existsSync(examplePath)) {
+      continue;
+    }
+    const values = parseEnvFile(examplePath);
+    const fileAnswers = answers[relativePath] ?? {};
+    let content = "";
+    const lines = import_node_fs3.default.readFileSync(examplePath, "utf-8").split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        content += line + "\n";
+        continue;
+      }
+      const separatorIndex = trimmed.indexOf("=");
+      if (separatorIndex === -1) {
+        content += line + "\n";
+        continue;
+      }
+      const key = trimmed.slice(0, separatorIndex).trim();
+      const value = fileAnswers[key] ?? values[key];
+      content += `${key}=${value}
+`;
+    }
+    const envPath = import_node_path3.default.join(targetDir, relativePath.replace(".env.example", ".env"));
+    import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(envPath), { recursive: true });
+    import_node_fs3.default.writeFileSync(envPath, content, "utf-8");
+  }
+}
+async function runPnpmInstall(targetDir) {
+  try {
+    await execFileAsync("pnpm", ["install", "--frozen-lockfile"], { cwd: targetDir, timeout: 3e5 });
+  } catch (error) {
+    const execError = error;
+    throw new Error(`Failed to install dependencies: ${execError.stderr ?? execError.stdout ?? String(error)}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectFrameworkFromDeps,
+  init,
+  loadConfig,
+  pluginRegistry
+});