@djangocfg/ext-base 1.0.3 → 1.0.5

package/dist/chunk-NXFE5CDE.js

@@ -0,0 +1,140 @@
+import { __require } from './chunk-3RG5ZIWI.js';
+
+// package.json
+var package_default = {
+  name: "@djangocfg/ext-base",
+  version: "1.0.5",
+  description: "Base utilities and common code for DjangoCFG extensions",
+  keywords: [
+    "django",
+    "djangocfg",
+    "extension",
+    "base",
+    "utilities",
+    "typescript",
+    "react"
+  ],
+  author: {
+    name: "DjangoCFG",
+    url: "https://djangocfg.com"
+  },
+  homepage: "https://hub.djangocfg.com/extensions/djangocfg-ext-base",
+  repository: {
+    type: "git",
+    url: "https://github.com/markolofsen/django-cfg.git",
+    directory: "extensions/base"
+  },
+  bugs: {
+    url: "https://github.com/markolofsen/django-cfg/issues"
+  },
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./hooks": {
+      types: "./dist/hooks.d.ts",
+      import: "./dist/hooks.js",
+      require: "./dist/hooks.cjs"
+    },
+    "./auth": {
+      types: "./dist/auth.d.ts",
+      import: "./dist/auth.js",
+      require: "./dist/auth.cjs"
+    },
+    "./api": {
+      types: "./dist/api.d.ts",
+      import: "./dist/api.js",
+      require: "./dist/api.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "src",
+    "preview.png",
+    "templates"
+  ],
+  bin: {
+    "djangocfg-ext": "./dist/cli.mjs"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    check: "tsc --noEmit",
+    test: "tsx src/cli/index.ts test",
+    cli: "tsx src/cli/index.ts",
+    "cli:help": "tsx src/cli/index.ts --help",
+    "cli:create": "tsx src/cli/index.ts create",
+    "cli:test": "tsx src/cli/index.ts test",
+    "cli:list": "tsx src/cli/index.ts list",
+    "cli:info": "tsx src/cli/index.ts info"
+  },
+  peerDependencies: {
+    "@djangocfg/api": "workspace:*",
+    consola: "^3.4.2",
+    react: "^18 || ^19",
+    "react-dom": "^18 || ^19",
+    swr: "^2.3.7"
+  },
+  dependencies: {
+    chalk: "^5.3.0",
+    consola: "^3.4.2",
+    picocolors: "^1.1.1",
+    prompts: "^2.4.2"
+  },
+  devDependencies: {
+    "@djangocfg/api": "workspace:*",
+    "@djangocfg/typescript-config": "workspace:*",
+    "@types/node": "^24.7.2",
+    "@types/prompts": "^2.4.9",
+    "@types/react": "^19.0.0",
+    swr: "^2.3.7",
+    tsup: "^8.5.0",
+    tsx: "^4.19.2",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/metadata.ts
+({
+  version: package_default.version,
+  npmUrl: `https://www.npmjs.com/package/${package_default.name}`,
+  installCommand: `pnpm add ${package_default.name}`,
+  packagePeerDependencies: package_default.peerDependencies});
+
+// src/config.ts
+var isDevelopment = process.env.NODE_ENV === "development";
+var isProduction = process.env.NODE_ENV === "production";
+var isStaticBuild = process.env.STATIC_BUILD === "true";
+function getApiUrl() {
+  return process.env.NEXT_PUBLIC_API_URL || "/api";
+}
+
+// src/api/createExtensionAPI.ts
+function createExtensionAPI(APIClass) {
+  let storage;
+  try {
+    const { api: accountsApi } = __require("@djangocfg/api");
+    storage = accountsApi._storage;
+  } catch (error) {
+    storage = void 0;
+  }
+  const apiUrl = isStaticBuild ? "" : getApiUrl();
+  return new APIClass(apiUrl, storage ? { storage } : void 0);
+}
+function getSharedAuthStorage() {
+  try {
+    const { api: accountsApi } = __require("@djangocfg/api");
+    return accountsApi._storage;
+  } catch (error) {
+    return void 0;
+  }
+}
+
+export { createExtensionAPI, getApiUrl, getSharedAuthStorage, isDevelopment, isProduction, isStaticBuild, package_default };

package/dist/cli.mjs

@@ -0,0 +1,530 @@
+#!/usr/bin/env node
+import { consola } from 'consola';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { existsSync, readdirSync, readFileSync, writeFileSync, statSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+// src/types/context.ts
+var EXTENSION_CATEGORIES = [
+  { title: "Forms", value: "forms" },
+  { title: "Payments", value: "payments" },
+  { title: "Content", value: "content" },
+  { title: "Support", value: "support" },
+  { title: "Utilities", value: "utilities" },
+  { title: "Analytics", value: "analytics" },
+  { title: "Security", value: "security" },
+  { title: "Integration", value: "integration" },
+  { title: "Other", value: "other" }
+];
+
+// src/cli/index.ts
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+  try {
+    const pkgPath = join(__dirname$1, "../../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "1.0.0";
+  }
+}
+var COMMANDS = {
+  create: "Create a new DjangoCFG extension",
+  test: "Quick create test extension (no prompts)",
+  help: "Show help",
+  "--help": "Show help",
+  "-h": "Show help"
+};
+function replacePlaceholders(content, replacements) {
+  let result = content;
+  for (const [key, value] of Object.entries(replacements)) {
+    result = result.replaceAll(key, value);
+  }
+  return result;
+}
+function copyTemplateRecursive(src, dest, replacements) {
+  if (!existsSync(src)) {
+    throw new Error(`Template not found: ${src}`);
+  }
+  const stats = statSync(src);
+  if (stats.isDirectory()) {
+    if (!existsSync(dest)) {
+      mkdirSync(dest, { recursive: true });
+    }
+    const files = readdirSync(src);
+    for (const file of files) {
+      const srcPath = join(src, file);
+      let destFile = file;
+      if (file.includes("__PROVIDER_NAME__")) {
+        destFile = file.replaceAll("__PROVIDER_NAME__", replacements["__PROVIDER_NAME__"]);
+      }
+      if (destFile.endsWith(".template")) {
+        destFile = destFile.slice(0, -9);
+      }
+      const destPath = join(dest, destFile);
+      copyTemplateRecursive(srcPath, destPath, replacements);
+    }
+  } else {
+    const content = readFileSync(src, "utf-8");
+    const replaced = replacePlaceholders(content, replacements);
+    writeFileSync(dest, replaced, "utf-8");
+  }
+}
+function printBanner() {
+  console.log();
+  console.log(chalk.cyan.bold("  \u{1F680} DjangoCFG Extension Manager"));
+  console.log(chalk.gray(`     v${getVersion()}`));
+  console.log();
+}
+async function checkPackageExists(packageName) {
+  try {
+    const encodedName = encodeURIComponent(packageName);
+    const response = await fetch(`https://registry.npmjs.org/${encodedName}`);
+    return response.status === 200;
+  } catch {
+    return false;
+  }
+}
+function checkDirectoryExists(packageName) {
+  const extDirName = packageName.replace("@", "").replace("/", "-");
+  const isInExtBase = process.cwd().endsWith("ext-base");
+  const baseDir = isInExtBase ? join(process.cwd(), "..") : join(process.cwd(), "extensions");
+  const extDir = join(baseDir, extDirName);
+  if (existsSync(extDir)) {
+    return { exists: true, path: extDir };
+  }
+  try {
+    const files = readdirSync(baseDir);
+    const lowerCaseName = extDirName.toLowerCase();
+    for (const file of files) {
+      if (file.toLowerCase() === lowerCaseName) {
+        const fullPath = join(baseDir, file);
+        const stats = statSync(fullPath);
+        if (stats.isDirectory()) {
+          return { exists: true, path: fullPath };
+        }
+      }
+    }
+  } catch {
+    return { exists: false };
+  }
+  return { exists: false };
+}
+function detectPackageManager() {
+  const managers = ["pnpm", "yarn", "npm"];
+  for (const manager of managers) {
+    try {
+      const result = execSync(`${manager} --version`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      if (result) {
+        return manager;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function printHelp() {
+  printBanner();
+  console.log(chalk.yellow.bold("Usage:"));
+  console.log(`  ${chalk.cyan("djangocfg-ext")} ${chalk.gray("[command]")}`);
+  console.log();
+  console.log(chalk.yellow.bold("Commands:"));
+  Object.entries(COMMANDS).forEach(([cmd, desc]) => {
+    console.log(`  ${chalk.cyan(cmd.padEnd(12))} ${chalk.gray(desc)}`);
+  });
+  console.log();
+  console.log(chalk.yellow.bold("Examples:"));
+  console.log(`  ${chalk.gray("$")} ${chalk.cyan("djangocfg-ext create")}`);
+  console.log();
+}
+async function createExtension() {
+  printBanner();
+  console.log(chalk.yellow("Create a new DjangoCFG extension"));
+  console.log();
+  let packageName = "";
+  let packageNameValid = false;
+  while (!packageNameValid) {
+    const nameResponse = await prompts({
+      type: "text",
+      name: "packageName",
+      message: 'Package name (e.g., "@my-org/my-extension" or "my-extension"):',
+      validate: (value) => {
+        if (!value) return "Package name is required";
+        const normalized = value.toLowerCase();
+        if (!/^(@[a-zA-Z0-9-]+\/)?[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(normalized)) {
+          return "Invalid package name format. Use @scope/name or name";
+        }
+        return true;
+      }
+    });
+    if (!nameResponse.packageName) {
+      consola.info("Extension creation cancelled");
+      return;
+    }
+    packageName = nameResponse.packageName.toLowerCase();
+    const dirCheck = checkDirectoryExists(packageName);
+    if (dirCheck.exists) {
+      consola.error(`Extension directory already exists: ${chalk.red(dirCheck.path)}`);
+      console.log(chalk.gray("Please try a different name."));
+      console.log();
+      continue;
+    }
+    consola.start(`Checking if ${chalk.cyan(packageName)} is available on npm...`);
+    const packageExists = await checkPackageExists(packageName);
+    if (packageExists) {
+      consola.error(`Package ${chalk.red(packageName)} already exists on npm!`);
+      console.log(chalk.gray("Please try a different name."));
+      console.log();
+      continue;
+    }
+    consola.success("Package name is available!");
+    console.log();
+    packageNameValid = true;
+  }
+  const response = await prompts([
+    {
+      type: "text",
+      name: "displayName",
+      message: 'Display name (e.g., "My Extension"):',
+      validate: (value) => value ? true : "Display name is required"
+    },
+    {
+      type: "text",
+      name: "description",
+      message: "Description:",
+      validate: (value) => value ? true : "Description is required"
+    },
+    {
+      type: "select",
+      name: "category",
+      message: "Category:",
+      choices: EXTENSION_CATEGORIES
+    }
+  ]);
+  if (!response.displayName) {
+    consola.info("Extension creation cancelled");
+    return;
+  }
+  const fullResponse = {
+    ...response,
+    packageName
+  };
+  const isInDjangoCfgMonorepo = existsSync(join(process.cwd(), "../../pnpm-workspace.yaml")) && existsSync(join(process.cwd(), "../../packages/api/package.json"));
+  let extDirName;
+  if (isInDjangoCfgMonorepo && fullResponse.packageName.startsWith("@djangocfg/")) {
+    extDirName = fullResponse.packageName.split("/")[1];
+  } else {
+    extDirName = fullResponse.packageName.replace("@", "").replace("/", "-");
+  }
+  const isInExtBase = process.cwd().endsWith("ext-base");
+  const extDir = isInExtBase ? join(process.cwd(), "..", extDirName) : join(process.cwd(), "extensions", extDirName);
+  console.log();
+  consola.start(`Creating extension: ${chalk.cyan(fullResponse.packageName)}`);
+  try {
+    const providerName = fullResponse.displayName.split(/[\s-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    const shortName = fullResponse.packageName.split("/").pop() || fullResponse.packageName.replace("@", "");
+    const marketplaceId = fullResponse.packageName.replace("@", "").replace("/", "-");
+    const marketplaceLink = `**[\u{1F4E6} View in Marketplace](https://hub.djangocfg.com/extensions/${marketplaceId})** \u2022 **[\u{1F4D6} Documentation](https://djangocfg.com)** \u2022 **[\u2B50 GitHub](https://github.com/markolofsen/django-cfg)**`;
+    const replacements = {
+      "__NAME__": shortName,
+      "__PACKAGE_NAME__": fullResponse.packageName,
+      "__DISPLAY_NAME__": fullResponse.displayName,
+      "__DESCRIPTION__": fullResponse.description,
+      "__CATEGORY__": fullResponse.category,
+      "__PROVIDER_NAME__": providerName,
+      "__MARKETPLACE_ID__": marketplaceId,
+      "__MARKETPLACE_LINK__": marketplaceLink
+    };
+    const templatePaths = [
+      // When running from built dist/ (installed from npm)
+      join(__dirname$1, "../templates/extension-template"),
+      // When running from src/ during development (tsx)
+      join(__dirname$1, "../../templates/extension-template"),
+      // Workspace path (for development from monorepo root)
+      join(process.cwd(), "extensions", "ext-base", "templates", "extension-template"),
+      // When running from ext-base directory
+      join(process.cwd(), "templates", "extension-template")
+    ];
+    let templateDir = null;
+    for (const path of templatePaths) {
+      if (existsSync(path)) {
+        templateDir = path;
+        break;
+      }
+    }
+    if (!templateDir) {
+      throw new Error("Extension template not found");
+    }
+    consola.start("Copying template files...");
+    copyTemplateRecursive(templateDir, extDir, replacements);
+    consola.success("Extension files created");
+    if (isInDjangoCfgMonorepo) {
+      consola.info("Detected djangocfg monorepo - using workspace:* for @djangocfg packages");
+      const pkgJsonPath = join(extDir, "package.json");
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const replaceDeps = (deps) => {
+        if (!deps) return;
+        for (const [key, value] of Object.entries(deps)) {
+          if (key.startsWith("@djangocfg/") && value === "latest") {
+            deps[key] = "workspace:*";
+          }
+        }
+      };
+      replaceDeps(pkgJson.dependencies);
+      replaceDeps(pkgJson.peerDependencies);
+      replaceDeps(pkgJson.devDependencies);
+      writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
+    }
+    console.log();
+    const packageManager = detectPackageManager();
+    if (packageManager) {
+      consola.start(`Installing dependencies with ${chalk.cyan(packageManager)}...`);
+      try {
+        execSync(`${packageManager} install`, {
+          cwd: extDir,
+          stdio: "inherit"
+        });
+        consola.success("Dependencies installed successfully");
+        console.log();
+        const playgroundDir = join(extDir, "playground");
+        if (existsSync(playgroundDir)) {
+          consola.start(`Installing playground dependencies with ${chalk.cyan(packageManager)}...`);
+          try {
+            execSync(`${packageManager} install`, {
+              cwd: playgroundDir,
+              stdio: "inherit"
+            });
+            consola.success("Playground dependencies installed successfully");
+            console.log();
+          } catch (error) {
+            consola.warn(`Failed to install playground dependencies. Please run: ${chalk.cyan(`cd ${extDirName}/playground && ${packageManager} install`)}`);
+            console.log();
+          }
+        }
+        consola.start("Running type check...");
+        try {
+          execSync(`${packageManager} run check`, {
+            cwd: extDir,
+            stdio: "inherit"
+          });
+          consola.success("Type check passed");
+        } catch (error) {
+          consola.warn("Type check failed. Please review and fix type errors.");
+        }
+      } catch (error) {
+        consola.warn(`Failed to install dependencies automatically. Please run: ${chalk.cyan(`cd ${extDirName} && ${packageManager} install`)}`);
+      }
+      console.log();
+    } else {
+      consola.warn("No package manager found (pnpm, yarn, or npm). Please install dependencies manually.");
+      console.log();
+    }
+    consola.success(`Extension created successfully: ${chalk.cyan(extDir)}`);
+    console.log();
+    console.log(chalk.yellow.bold("Next steps:"));
+    console.log();
+    console.log(chalk.gray("1. Navigate to extension directory:"));
+    console.log(chalk.cyan(`   cd ${extDirName}`));
+    console.log();
+    console.log(chalk.gray("2. Build the extension:"));
+    console.log(chalk.cyan(`   ${packageManager || "pnpm"} build`));
+    console.log();
+    console.log(chalk.gray("3. Add your features and customize:"));
+    console.log(chalk.cyan(`   - Edit src/config.ts to add features`));
+    console.log(chalk.cyan(`   - Add components, hooks, and utilities`));
+    console.log(chalk.cyan(`   - Update README.md with usage examples`));
+    console.log();
+    consola.info("Documentation: https://djangocfg.com/docs");
+  } catch (error) {
+    consola.error("Failed to create extension:", error);
+    process.exit(1);
+  }
+}
+async function createTestExtension() {
+  printBanner();
+  const isInExtBase = process.cwd().endsWith("ext-base");
+  const baseDir = isInExtBase ? join(process.cwd(), "..") : join(process.cwd(), "extensions");
+  if (existsSync(baseDir)) {
+    const files = readdirSync(baseDir);
+    const testExtensions = files.filter((f) => f.startsWith("test-"));
+    if (testExtensions.length > 0) {
+      consola.info(`Cleaning up ${testExtensions.length} old test extension(s)...`);
+      for (const testExt of testExtensions) {
+        const testPath = join(baseDir, testExt);
+        try {
+          execSync(`rm -rf "${testPath}"`, { stdio: "ignore" });
+          consola.success(`Removed ${testExt}`);
+        } catch (error) {
+          consola.warn(`Failed to remove ${testExt}`);
+        }
+      }
+      console.log();
+    }
+  }
+  const timestamp = Date.now().toString(36);
+  const packageName = `@djangocfg/test-${timestamp}`;
+  const displayName = `Test ${timestamp}`;
+  const description = "Test extension created for development";
+  const category = "utilities";
+  console.log(chalk.yellow("Quick Test Extension Creation"));
+  console.log();
+  console.log(chalk.cyan(`Package: ${packageName}`));
+  console.log(chalk.cyan(`Name: ${displayName}`));
+  console.log();
+  const isInDjangoCfgMonorepo = existsSync(join(process.cwd(), "../../pnpm-workspace.yaml")) && existsSync(join(process.cwd(), "../../packages/api/package.json"));
+  const extDirName = packageName.split("/")[1];
+  const extDir = isInExtBase ? join(process.cwd(), "..", extDirName) : join(process.cwd(), "extensions", extDirName);
+  if (existsSync(extDir)) {
+    consola.error(`Extension directory already exists: ${chalk.red(extDir)}`);
+    process.exit(1);
+  }
+  consola.start(`Creating test extension: ${chalk.cyan(packageName)}`);
+  try {
+    const providerName = displayName.split(/[\s-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    const shortName = packageName.split("/").pop() || packageName.replace("@", "");
+    const marketplaceId = packageName.replace("@", "").replace("/", "-");
+    const marketplaceLink = `**[\u{1F4E6} View in Marketplace](https://hub.djangocfg.com/extensions/${marketplaceId})** \u2022 **[\u{1F4D6} Documentation](https://djangocfg.com)** \u2022 **[\u2B50 GitHub](https://github.com/markolofsen/django-cfg)**`;
+    const replacements = {
+      "__NAME__": shortName,
+      "__PACKAGE_NAME__": packageName,
+      "__DISPLAY_NAME__": displayName,
+      "__DESCRIPTION__": description,
+      "__CATEGORY__": category,
+      "__PROVIDER_NAME__": providerName,
+      "__MARKETPLACE_ID__": marketplaceId,
+      "__MARKETPLACE_LINK__": marketplaceLink
+    };
+    const templatePaths = [
+      join(__dirname$1, "../templates/extension-template"),
+      join(__dirname$1, "../../templates/extension-template"),
+      join(process.cwd(), "extensions", "ext-base", "templates", "extension-template"),
+      join(process.cwd(), "templates", "extension-template")
+    ];
+    let templateDir = null;
+    for (const path of templatePaths) {
+      if (existsSync(path)) {
+        templateDir = path;
+        break;
+      }
+    }
+    if (!templateDir) {
+      throw new Error("Extension template not found");
+    }
+    consola.start("Copying template files...");
+    copyTemplateRecursive(templateDir, extDir, replacements);
+    consola.success("Extension files created");
+    if (isInDjangoCfgMonorepo) {
+      consola.info("Detected djangocfg monorepo - using workspace:* for @djangocfg packages");
+      const pkgJsonPath = join(extDir, "package.json");
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const replaceDeps = (deps) => {
+        if (!deps) return;
+        for (const [key, value] of Object.entries(deps)) {
+          if (key.startsWith("@djangocfg/") && value === "latest") {
+            deps[key] = "workspace:*";
+          }
+        }
+      };
+      replaceDeps(pkgJson.dependencies);
+      replaceDeps(pkgJson.peerDependencies);
+      replaceDeps(pkgJson.devDependencies);
+      const playgroundPkgPath = join(extDir, "playground", "package.json");
+      if (existsSync(playgroundPkgPath)) {
+        const playgroundPkg = JSON.parse(readFileSync(playgroundPkgPath, "utf-8"));
+        replaceDeps(playgroundPkg.dependencies);
+        replaceDeps(playgroundPkg.devDependencies);
+        writeFileSync(playgroundPkgPath, JSON.stringify(playgroundPkg, null, 2) + "\n", "utf-8");
+      }
+      writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n", "utf-8");
+    }
+    console.log();
+    const packageManager = detectPackageManager();
+    if (packageManager) {
+      consola.start(`Installing dependencies with ${chalk.cyan(packageManager)}...`);
+      try {
+        execSync(`${packageManager} install`, {
+          cwd: extDir,
+          stdio: "inherit"
+        });
+        consola.success("Dependencies installed successfully");
+        console.log();
+        const playgroundDir = join(extDir, "playground");
+        if (existsSync(playgroundDir)) {
+          consola.start(`Installing playground dependencies with ${chalk.cyan(packageManager)}...`);
+          try {
+            execSync(`${packageManager} install`, {
+              cwd: playgroundDir,
+              stdio: "inherit"
+            });
+            consola.success("Playground dependencies installed successfully");
+            console.log();
+          } catch (error) {
+            consola.warn(`Failed to install playground dependencies.`);
+            console.log();
+          }
+        }
+        consola.start("Running type check...");
+        try {
+          execSync(`${packageManager} run check`, {
+            cwd: extDir,
+            stdio: "inherit"
+          });
+          consola.success("Type check passed");
+        } catch (error) {
+          consola.warn("Type check failed. Please review and fix type errors.");
+        }
+      } catch (error) {
+        consola.warn(`Failed to install dependencies automatically.`);
+      }
+      console.log();
+    }
+    consola.success(`Test extension created: ${chalk.cyan(extDir)}`);
+    console.log();
+    console.log(chalk.yellow.bold("Quick commands:"));
+    console.log();
+    console.log(chalk.cyan(`  cd ${extDirName}`));
+    console.log(chalk.cyan(`  pnpm build`));
+    console.log(chalk.cyan(`  pnpm dev:playground`));
+    console.log();
+  } catch (error) {
+    consola.error("Failed to create test extension:", error);
+    process.exit(1);
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command) {
+    printHelp();
+    return;
+  }
+  switch (command) {
+    case "create":
+      await createExtension();
+      break;
+    case "test":
+      await createTestExtension();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    default:
+      consola.error(`Unknown command: ${command}`);
+      console.log();
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  consola.error("CLI error:", error);
+  process.exit(1);
+});