@stormycms/cli 0.0.10

package/dist/cli.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// ../../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/cli.ts
+var import_commander = require("commander");
+
+// 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();
+async function loadBuiltInPlugins() {
+  try {
+    const reactPlugin = await import("@stormycms/react/plugin");
+    if (reactPlugin.default) {
+      pluginRegistry.registerFrameworkPlugin(reactPlugin.default);
+    }
+  } catch {
+  }
+}
+
+// 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/generate.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+async function generate(options) {
+  const cwd = process.cwd();
+  const config = await loadConfig(cwd);
+  await loadBuiltInPlugins();
+  await pluginRegistry.loadConfigPlugins(cwd);
+  let framework = config.framework;
+  if (!framework) {
+    framework = await detectFrameworkFromDeps(cwd);
+    if (!framework) {
+      framework = await pluginRegistry.detectFramework(cwd);
+    }
+  }
+  if (!framework) {
+    console.error(
+      "Could not detect framework. Please install a Stormy CMS framework package (e.g., @stormycms/react) or specify framework in stormy.config.ts"
+    );
+    process.exit(1);
+  }
+  const plugin = pluginRegistry.getFrameworkPlugin(framework);
+  if (!plugin) {
+    console.error(
+      `Framework plugin '${framework}' not found. Please install @stormycms/${framework} or a compatible plugin.`
+    );
+    console.error(`Available plugins: ${pluginRegistry.listFrameworkPlugins().join(", ") || "none"}`);
+    process.exit(1);
+  }
+  console.log(`Using framework plugin: ${plugin.name}`);
+  try {
+    runGeneration(plugin, options);
+  } catch (error) {
+    console.error("Generation failed:", error);
+    process.exit(1);
+  }
+}
+function runGeneration(plugin, options) {
+  const componentsDir = import_node_path3.default.resolve(process.cwd(), options.components);
+  const outputPath = import_node_path3.default.resolve(process.cwd(), options.output);
+  const outputDir = import_node_path3.default.dirname(outputPath);
+  if (!import_node_fs3.default.existsSync(componentsDir)) {
+    console.error(`Components directory not found: ${componentsDir}`);
+    process.exit(1);
+  }
+  const components = plugin.parseComponents(options);
+  if (components.length === 0) {
+    console.warn("No valid components found in component files.");
+    return;
+  }
+  const relativePath = import_node_path3.default.relative(outputDir, componentsDir).replace(/\\/g, "/");
+  const importBasePath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  const output = plugin.generateSchema(components, importBasePath);
+  import_node_fs3.default.mkdirSync(outputDir, { recursive: true });
+  import_node_fs3.default.writeFileSync(outputPath, output, "utf-8");
+  const totalFields = components.reduce((sum, c) => sum + c.fields.length, 0);
+  console.log(`Generated ${outputPath} with ${components.length} component(s) and ${totalFields} field(s)`);
+}
+
+// src/init.ts
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path4 = __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_path4.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_path4.default.resolve(options.target) : await promptTargetDirectory(projectName);
+  if (import_node_fs4.default.existsSync(targetDir) && import_node_fs4.default.readdirSync(targetDir).length > 0) {
+    throw new Error(`Target directory is not empty: ${targetDir}`);
+  }
+  import_node_fs4.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_path4.default.relative(process.cwd(), targetDir);
+  const cdTarget = relativeTarget.startsWith("..") || import_node_path4.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_path4.default.resolve(__dirname, "../boilerplate.zip"), import_node_path4.default.resolve(__dirname, "../../boilerplate.zip")];
+  for (const candidate of candidates) {
+    if (import_node_fs4.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_path4.default.resolve(response.target);
+}
+function replaceProjectName(targetDir, projectName) {
+  for (const relativePath of filesToReplaceProjectName) {
+    const filePath = import_node_path4.default.join(targetDir, relativePath);
+    if (!import_node_fs4.default.existsSync(filePath)) {
+      continue;
+    }
+    const content = import_node_fs4.default.readFileSync(filePath, "utf-8");
+    const updated = content.replaceAll("stormy-cms-nextjs-boilerplate", projectName);
+    import_node_fs4.default.writeFileSync(filePath, updated, "utf-8");
+  }
+}
+function parseEnvFile(filePath) {
+  const content = import_node_fs4.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_path4.default.join(targetDir, relativePath);
+    if (!import_node_fs4.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_path4.default.join(targetDir, ".git");
+  if (import_node_fs4.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_path4.default.join(targetDir, relativePath);
+    if (!import_node_fs4.default.existsSync(examplePath)) {
+      continue;
+    }
+    const values = parseEnvFile(examplePath);
+    const fileAnswers = answers[relativePath] ?? {};
+    let content = "";
+    const lines = import_node_fs4.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_path4.default.join(targetDir, relativePath.replace(".env.example", ".env"));
+    import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(envPath), { recursive: true });
+    import_node_fs4.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)}`);
+  }
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("stormy").description("Stormy CMS CLI tools").version("0.1.0");
+program.command("generate").description("Generate CMS-wrapped components from component files").option("-c, --components <path>", "Path to the components directory", "./src/components").option("-o, --output <path>", "Output file path", "./componentschema.ts").option("-f, --framework <name>", "Framework to use (auto-detected if not specified)").action(async (options) => {
+  await generate({
+    components: options.components,
+    output: options.output
+  });
+});
+program.command("init").description("Initialize a new Stormy CMS project from the boilerplate").option("-n, --name <name>", "Project name").option("-t, --target <path>", "Target directory (defaults to ./{project name})").option("--skip-env", "Skip environment variable prompts and use example values").option("--skip-install", "Create the project without installing dependencies").action(async (options) => {
+  try {
+    await init({
+      projectName: options.name,
+      target: options.target,
+      skipEnv: options.skipEnv,
+      skipInstall: options.skipInstall
+    });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  }
+});
+program.parse();

package/dist/index.d.mts

@@ -0,0 +1,100 @@
+/**
+ * Stormy CMS Plugin Interface
+ *
+ * Frameworks implement this interface to provide component parsing
+ * and schema generation capabilities.
+ */
+type PropField = {
+    label: string;
+    prop: string;
+    field: string;
+    fn?: string;
+    options?: string[];
+    fieldTypes?: string[];
+    subFields?: PropField[];
+};
+type ComponentInfo = {
+    name: string;
+    fileName: string;
+    export: string;
+    componentId: string;
+    label: string;
+    fields: PropField[];
+};
+type GenerateOptions = {
+    components: string;
+    output: string;
+};
+type InitOptions = {
+    projectName?: string;
+    target?: string;
+    skipEnv?: boolean;
+    skipInstall?: boolean;
+};
+type StormyConfig = {
+    framework?: string;
+    components: string;
+    output: string;
+    plugins?: string[];
+};
+/**
+ * A Stormy CMS plugin for a specific framework
+ */
+interface StormyPlugin {
+    /** Plugin name (e.g., 'react', 'vue', 'svelte') */
+    name: string;
+    /** Detect if this framework is used in the project */
+    detect: (cwd: string) => boolean | Promise<boolean>;
+    /** Parse component files and extract metadata */
+    parseComponents: (options: GenerateOptions) => ComponentInfo[];
+    /** Generate the schema file content */
+    generateSchema: (components: ComponentInfo[], importBasePath: string) => string;
+}
+/**
+ * Custom plugin interface for consumers
+ */
+interface CustomPlugin {
+    name: string;
+    setup: (api: PluginAPI) => void;
+}
+interface PluginAPI {
+    /** Register a parser for specific file extensions */
+    registerParser: (extensions: string[], parser: FileParser) => void;
+    /** Register a field type mapping */
+    registerFieldType: (typeName: string, fieldType: string) => void;
+    /** Hook into the generate lifecycle */
+    onBeforeGenerate: (callback: (options: GenerateOptions) => void | Promise<void>) => void;
+    onAfterGenerate: (callback: (options: GenerateOptions, output: string) => void | Promise<void>) => void;
+}
+type FileParser = (filePath: string, content: string) => ComponentInfo | null;
+
+declare class PluginRegistry {
+    #private;
+    constructor();
+    /** Register a framework plugin */
+    registerFrameworkPlugin(plugin: StormyPlugin): void;
+    /** Register a custom plugin */
+    registerCustomPlugin(plugin: CustomPlugin): void;
+    /** Get a framework plugin by name */
+    getFrameworkPlugin(name: string): StormyPlugin | undefined;
+    /** List all registered framework plugins */
+    listFrameworkPlugins(): string[];
+    /** Auto-detect framework from project dependencies */
+    detectFramework(cwd: string): Promise<string | null>;
+    /** Load plugins from stormy.config.ts */
+    loadConfigPlugins(cwd: string): Promise<void>;
+}
+declare const pluginRegistry: PluginRegistry;
+
+/**
+ * Load Stormy configuration from stormy.config.ts or package.json
+ */
+declare function loadConfig(cwd: string): Promise<StormyConfig>;
+/**
+ * Detect framework from package.json dependencies
+ */
+declare function detectFrameworkFromDeps(cwd: string): Promise<string | null>;
+
+declare function init(options: InitOptions): Promise<void>;
+
+export { type ComponentInfo, type CustomPlugin, type FileParser, type GenerateOptions, type InitOptions, type PluginAPI, type PropField, type StormyConfig, type StormyPlugin, detectFrameworkFromDeps, init, loadConfig, pluginRegistry };

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Stormy CMS Plugin Interface
+ *
+ * Frameworks implement this interface to provide component parsing
+ * and schema generation capabilities.
+ */
+type PropField = {
+    label: string;
+    prop: string;
+    field: string;
+    fn?: string;
+    options?: string[];
+    fieldTypes?: string[];
+    subFields?: PropField[];
+};
+type ComponentInfo = {
+    name: string;
+    fileName: string;
+    export: string;
+    componentId: string;
+    label: string;
+    fields: PropField[];
+};
+type GenerateOptions = {
+    components: string;
+    output: string;
+};
+type InitOptions = {
+    projectName?: string;
+    target?: string;
+    skipEnv?: boolean;
+    skipInstall?: boolean;
+};
+type StormyConfig = {
+    framework?: string;
+    components: string;
+    output: string;
+    plugins?: string[];
+};
+/**
+ * A Stormy CMS plugin for a specific framework
+ */
+interface StormyPlugin {
+    /** Plugin name (e.g., 'react', 'vue', 'svelte') */
+    name: string;
+    /** Detect if this framework is used in the project */
+    detect: (cwd: string) => boolean | Promise<boolean>;
+    /** Parse component files and extract metadata */
+    parseComponents: (options: GenerateOptions) => ComponentInfo[];
+    /** Generate the schema file content */
+    generateSchema: (components: ComponentInfo[], importBasePath: string) => string;
+}
+/**
+ * Custom plugin interface for consumers
+ */
+interface CustomPlugin {
+    name: string;
+    setup: (api: PluginAPI) => void;
+}
+interface PluginAPI {
+    /** Register a parser for specific file extensions */
+    registerParser: (extensions: string[], parser: FileParser) => void;
+    /** Register a field type mapping */
+    registerFieldType: (typeName: string, fieldType: string) => void;
+    /** Hook into the generate lifecycle */
+    onBeforeGenerate: (callback: (options: GenerateOptions) => void | Promise<void>) => void;
+    onAfterGenerate: (callback: (options: GenerateOptions, output: string) => void | Promise<void>) => void;
+}
+type FileParser = (filePath: string, content: string) => ComponentInfo | null;
+
+declare class PluginRegistry {
+    #private;
+    constructor();
+    /** Register a framework plugin */
+    registerFrameworkPlugin(plugin: StormyPlugin): void;
+    /** Register a custom plugin */
+    registerCustomPlugin(plugin: CustomPlugin): void;
+    /** Get a framework plugin by name */
+    getFrameworkPlugin(name: string): StormyPlugin | undefined;
+    /** List all registered framework plugins */
+    listFrameworkPlugins(): string[];
+    /** Auto-detect framework from project dependencies */
+    detectFramework(cwd: string): Promise<string | null>;
+    /** Load plugins from stormy.config.ts */
+    loadConfigPlugins(cwd: string): Promise<void>;
+}
+declare const pluginRegistry: PluginRegistry;
+
+/**
+ * Load Stormy configuration from stormy.config.ts or package.json
+ */
+declare function loadConfig(cwd: string): Promise<StormyConfig>;
+/**
+ * Detect framework from package.json dependencies
+ */
+declare function detectFrameworkFromDeps(cwd: string): Promise<string | null>;
+
+declare function init(options: InitOptions): Promise<void>;
+
+export { type ComponentInfo, type CustomPlugin, type FileParser, type GenerateOptions, type InitOptions, type PluginAPI, type PropField, type StormyConfig, type StormyPlugin, detectFrameworkFromDeps, init, loadConfig, pluginRegistry };