@makerkit/cli 1.2.1

package/dist/index.js

@@ -0,0 +1,734 @@
+#!/usr/bin/env node
+
+// src/commands/blog/generate/generate-blog.command.ts
+import { join as join2 } from "path";
+
+// src/plugins-model.ts
+import invariant from "tiny-invariant";
+var PluginsModel = {
+  CookieBanner: {
+    name: `Cookie Banner`,
+    id: `cookie-banner`,
+    branch: `cookie-banner`,
+    description: `Add a cookie banner to your site.`
+  }
+};
+function getPluginById(id) {
+  return Object.values(PluginsModel).find((plugin) => plugin.id === id);
+}
+function validatePlugin(pluginId) {
+  const plugin = getPluginById(pluginId);
+  invariant(plugin, `Plugin ${pluginId} not found`);
+  return plugin;
+}
+
+// src/kits-model.ts
+import invariant2 from "tiny-invariant";
+var KitsModel = {
+  NextJsFirebase: {
+    name: `Next.js Firebase`,
+    id: `next-firebase`,
+    repository: `git@github.com:makerkit/next-firebase-saas-kit`,
+    blogPath: `_posts`,
+    localePath: `public/locales`,
+    plugins: [PluginsModel.CookieBanner.id]
+  },
+  NextJsSupabase: {
+    name: `Next.js Supabase`,
+    id: `next-supabase`,
+    localePath: `public/locales`,
+    blogPath: `src/content/posts`,
+    repository: `git@github.com:makerkit/next-supabase-saas-kit`,
+    plugins: []
+  },
+  NextJsSupabaseLite: {
+    name: `Next.js Supabase Lite`,
+    id: `next-supabase-lite`,
+    localePath: `public/locales`,
+    blogPath: `src/content/posts`,
+    repository: `git@github.com:makerkit/next-supabase-saas-kit-lite`,
+    plugins: []
+  },
+  RemixFirebase: {
+    name: `Remix Firebase`,
+    id: `remix-firebase`,
+    localePath: `public/locales`,
+    blogPath: "",
+    repository: `git@github.com:makerkit/remix-firebase-saas-kit`,
+    plugins: []
+  },
+  RemixSupabase: {
+    name: `Remix Supabase`,
+    id: `remix-supabase`,
+    localePath: `public/locales`,
+    blogPath: "",
+    repository: `git@github.com:makerkit/remix-supabase-saas-kit`,
+    plugins: []
+  }
+};
+function getKitById(id) {
+  return Object.values(KitsModel).find((kit) => kit.id === id);
+}
+function validateKit(kitId) {
+  const kit = getKitById(kitId);
+  invariant2(kit, `Kit ${kitId} not found`);
+  return kit;
+}
+
+// src/utils/openai-client.ts
+import OpenAI from "openai";
+function getOpenAIClient() {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "OPENAI_API_KEY env variable is not set. Please set it in your .env.local file of your Makerkit workspace."
+    );
+  }
+  return new OpenAI({ apiKey });
+}
+var openai_client_default = getOpenAIClient;
+
+// src/utils/workspace.ts
+import { join } from "path";
+import chalk from "chalk";
+import fs from "fs-extra";
+var Workspace = class _Workspace {
+  static async getKitMeta() {
+    const packageJson = await getPackageJson();
+    const kit = await detectKitVersion();
+    return {
+      ...kit,
+      version: packageJson.version
+    };
+  }
+  static async logWorkspaceInfo() {
+    const meta = await _Workspace.getKitMeta();
+    console.log(
+      `Makerkit version: ${chalk.cyan(meta.name)} - ${chalk.cyan(
+        meta.version
+      )}.
+`
+    );
+  }
+};
+async function detectKitVersion() {
+  const packageJson = await getPackageJson();
+  if (!packageJson) {
+    throw new Error(
+      "No package.json found. Please run this command in a Makerkit workspace."
+    );
+  }
+  const deps = Object.keys(packageJson.dependencies ?? []);
+  if (deps.includes("next") && deps.includes("firebase")) {
+    return KitsModel.NextJsFirebase;
+  }
+  if (deps.includes("next") && deps.includes("supabase")) {
+    return KitsModel.NextJsSupabase;
+  }
+  if (deps.includes("@remix-run/react") && deps.includes("firebase")) {
+    return KitsModel.NextJsSupabaseLite;
+  }
+  if (deps.includes("@remix-run/react") && deps.includes("supabase")) {
+    return KitsModel.RemixSupabase;
+  }
+  throw new Error(
+    "Could not detect Makerkit workspace. Please run this command in a Makerkit workspace."
+  );
+}
+async function getPackageJson() {
+  return fs.readJSON(join(process.cwd(), "package.json")).catch(() => void 0);
+}
+
+// src/commands/blog/generate/generate-blog.command.ts
+import chalk2 from "chalk";
+import fs2 from "fs-extra";
+import ora from "ora";
+import prompts from "prompts";
+import { z } from "zod";
+var schema = z.object({
+  title: z.string().min(1).max(70),
+  category: z.string().min(1).max(70),
+  wordCount: z.number().min(250).max(2500),
+  prompt: z.string().optional().transform((value) => value || "")
+});
+function generateBlogCommand(parentCommand) {
+  return parentCommand.command("generate").description("Generate your blog posts with AI").action(async () => {
+    const { title, prompt, category, wordCount } = schema.parse(
+      await getPrompts()
+    );
+    const content = await generateBlogPost({ title, prompt, wordCount });
+    const mdx = await getMdxPostTemplate({ title, category, content });
+    return writeMdxPostTemplate(mdx, title);
+  });
+}
+function getPrompts() {
+  return prompts([
+    {
+      type: "text",
+      name: "title",
+      message: `Enter your ${chalk2.cyan("title")}.`
+    },
+    {
+      type: "text",
+      name: "category",
+      message: `Enter your ${chalk2.cyan(
+        "category"
+      )}. If it doesn't exist yet, you will need to add it manually to your blog.`
+    },
+    {
+      type: "number",
+      name: "wordCount",
+      message: `Enter your target ${chalk2.cyan(
+        "word count"
+      )} (from 250 words, up to 2500).`
+    },
+    {
+      type: "text",
+      name: "prompt",
+      message: `Would you like to add your own instructions to the AI? (optional)`
+    }
+  ]);
+}
+async function generateBlogPost(params) {
+  const client = openai_client_default();
+  const prompt = getPostPrompt(params);
+  const spinner = ora(`Generating blog post...`).start();
+  try {
+    const response = await client.chat.completions.create({
+      model: `gpt-3.5-turbo`,
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      max_tokens: params.wordCount,
+      temperature: 0.7
+    });
+    const content = response.choices[0].message.content ?? "";
+    spinner.succeed(`Blog post generated successfully`);
+    console.log(`Used ${response.usage?.total_tokens} tokens`);
+    return content;
+  } catch (e) {
+    console.error(e);
+    spinner.fail(`Failed to generate blog post`);
+    process.exit(1);
+  }
+}
+async function getMdxPostTemplate(params) {
+  const kit = await Workspace.getKitMeta();
+  const isFirebaseKit = kit.id === KitsModel.NextJsFirebase.id;
+  const categoryProp = isFirebaseKit ? "collection" : "category";
+  const descriptionProp = isFirebaseKit ? "excerpt" : "description";
+  const imageProp = isFirebaseKit ? "coverImage" : "image";
+  return `
+---
+title: "${params.title}"
+${categoryProp}: "${params.category}"
+date: "${(/* @__PURE__ */ new Date()).toISOString()}"
+${descriptionProp}: ""
+live: false
+${imageProp}: ""
+---
+
+${params.content}
+`.trim();
+}
+async function writeMdxPostTemplate(template, title) {
+  const kit = await Workspace.getKitMeta();
+  const spinner = ora(`Storing blog post...`).start();
+  try {
+    let blogPath = kit.blogPath;
+    if (!blogPath) {
+      blogPath = await prompts({
+        type: "text",
+        name: "blogPath",
+        message: `This kit does not support blog posts yet. You can still generate a blog post, but you'll need to manually add it to your blog. Please enter your blog path (e.g. src/content/posts). The path needs to exist.`
+      }).then((response) => response.blogPath);
+    }
+    const slug = slugify(title);
+    const path = join2(process.cwd(), blogPath, `${slug}.mdx`);
+    await fs2.writeFile(path, template);
+    spinner.succeed(`Blog post stored successfully`);
+  } catch (e) {
+    console.error(e);
+    spinner.fail(`Failed to store blog post`);
+  }
+}
+function getPostPrompt(params) {
+  return `
+    Generate a professional blog post with title "${params.title}".
+    Rules:
+    
+- The post must be below ${params.wordCount} words
+- Output text using valid Markdown
+- Write professional text while balancing simplicity and complexity in your language and sentence structures.
+- Be an extremely smart, interesting, funny, witty, and confident writer. Readers admire you! 
+- Use several paragraphs and an accurate level 2 and 3 headings before each paragraph to maximize readability.
+- Do include level 4 headings (h4) to break complex paragraphs
+- Ensure that headings do not include decimals or numbers with periods. Ensure they're formatted using Markdown.
+- Repeat the main keywords and phrases often for SEO
+  
+  ${params.prompt ?? ""}
+`.trim();
+}
+function slugify(text) {
+  return (text ?? "").toString().normalize("NFKD").toLowerCase().trim().replace(/\_/g, "-").replace(/\s+/g, "-").replace(/\-\-+/g, "--").replace(/\_$/g, "");
+}
+
+// src/commands/blog/blog.command.ts
+import { Command } from "commander";
+var blogCommand = new Command().name("blog").description("Manage and generate your blog posts").hook("preAction", () => {
+  return Workspace.logWorkspaceInfo();
+});
+generateBlogCommand(blogCommand);
+
+// src/commands/i18n/i18n-service.ts
+import { join as join3 } from "path";
+import chalk3 from "chalk";
+import fs3 from "fs-extra";
+var I18nService = class {
+  /**
+   * @name verify
+   * @description Verifies if the locale files are in sync
+   */
+  static async verify(base = "en") {
+    const kit = await Workspace.getKitMeta();
+    const allLocales = fs3.readdirSync(kit.localePath).filter((locale) => {
+      return locale !== base;
+    });
+    const baseLocaleFolderPath = `${kit.localePath}/${base}`;
+    const localeFiles = fs3.readdirSync(baseLocaleFolderPath).filter((file) => {
+      return file.endsWith(".json");
+    });
+    for (const localeFile of localeFiles) {
+      for (const locale of allLocales) {
+        const baseLocaleFilePath = `${baseLocaleFolderPath}/${localeFile}`;
+        const targetLocaleFilePath = `${kit.localePath}/${locale}/${localeFile}`;
+        const baseLocaleFile = fs3.readJSONSync(baseLocaleFilePath);
+        const file = fs3.readJSONSync(targetLocaleFilePath);
+        const missingKeys = collectMissingKeys([baseLocaleFile, file]);
+        if (!missingKeys.length) {
+          console.log(
+            chalk3.green(`Locale ${locale}/${localeFile} is in sync!`)
+          );
+          continue;
+        }
+        console.log(
+          chalk3.yellow(
+            `Locale ${locale}/${localeFile} is missing the following keys: ${missingKeys.join(
+              ", "
+            )}`
+          )
+        );
+      }
+    }
+  }
+  /**
+   * @name translate
+   * @description Translates the locale files from source to target
+   * @param source
+   * @param target
+   */
+  static async translate(source, target) {
+    const kit = await Workspace.getKitMeta();
+    const client = openai_client_default();
+    const targetJsonPath = `${kit.localePath}/${target}`;
+    const sourceLocalePath = `${kit.localePath}/${source}`;
+    const sourceLocale = await fs3.exists(sourceLocalePath);
+    if (!sourceLocale) {
+      throw new Error(`Source locale at ${sourceLocalePath} not found`);
+    }
+    const files = fs3.readdirSync(sourceLocalePath).filter((file) => {
+      return file.endsWith(".json");
+    });
+    console.log(`Found the following files: ${files.join(", ")}`);
+    for (const file of files) {
+      const data = {};
+      const localeFile = fs3.readJSONSync(join3(sourceLocalePath, file));
+      console.log(
+        chalk3.cyan(`Translating "${file}". This can take a while...`)
+      );
+      for (const key in localeFile) {
+        data[key] = await translateKey(source, target, localeFile[key], client);
+      }
+      console.log(chalk3.green(`File "${file}" successfully translated!`));
+      console.log(chalk3.cyan(`Writing file "${file}" to ${targetJsonPath}`));
+      await fs3.exists(targetJsonPath) || await fs3.mkdir(targetJsonPath);
+      await fs3.writeJSON(join3(targetJsonPath, file), data, {});
+      console.log(chalk3.green(`File "${file}" successfully written!`));
+    }
+  }
+};
+async function translateKey(source, target, key, client) {
+  if (typeof key === "string") {
+    return translateString(source, target, key, client);
+  }
+  const data = {};
+  for (const k in key) {
+    data[k] = await translateKey(source, target, key[k], client);
+  }
+  return data;
+}
+async function translateString(source, target, key, client) {
+  if (!key.trim() || key.length <= 1) {
+    return "";
+  }
+  const response = await client.chat.completions.create({
+    model: "gpt-3.5-turbo",
+    max_tokens: target.split(" ").length + 50,
+    temperature: 0.3,
+    messages: [
+      {
+        role: "user",
+        content: `Translate the text from locale ${source} to ${target}. Text: ${key}. Translation:`
+      }
+    ]
+  });
+  return response.choices[0].message.content ?? "";
+}
+function collectMissingKeys(objects) {
+  const allKeys = [];
+  objects.forEach((obj) => {
+    Object.keys(obj).forEach((key) => {
+      if (!allKeys.includes(key)) {
+        allKeys.push(key);
+      }
+    });
+  });
+  const missingKeys = [];
+  objects.forEach((obj) => {
+    allKeys.forEach((key) => {
+      if (!Object.keys(obj).includes(key)) {
+        missingKeys.push(key);
+      }
+    });
+  });
+  return missingKeys;
+}
+
+// src/commands/i18n/translate/translate.command.ts
+import chalk4 from "chalk";
+import prompts2 from "prompts";
+function createTranslateI18nCommand(parentCommand) {
+  return parentCommand.command("translate").argument("[source-locale]", "Source Locale").argument("[target-locale]", "Target Locale").description("Translate i18n files from source locale to target locale").action(async (sourceLocale, targetLocale) => {
+    const locales = await promptLocales(sourceLocale, targetLocale);
+    await I18nService.translate(locales.sourceLocale, locales.targetLocale);
+  });
+}
+async function promptLocales(maybeSource, maybeTarget) {
+  const hint = "e.g. en, fr, es, etc.";
+  const sourceLocale = maybeSource || (await prompts2([
+    {
+      type: "text",
+      name: "locale",
+      message: `Enter your ${chalk4.cyan("Source Locale")}. ${hint}`,
+      hint
+    }
+  ])).locale;
+  const targetLocale = maybeTarget || (await prompts2([
+    {
+      type: "text",
+      name: "locale",
+      message: `Enter your ${chalk4.cyan("Target Locale")}. ${hint}`,
+      hint
+    }
+  ])).locale;
+  return {
+    sourceLocale,
+    targetLocale
+  };
+}
+
+// src/commands/i18n/verify/verify.command.ts
+function createVerifyI18nCommand(parentCommand) {
+  return parentCommand.command("verify").argument("[base-locale]", "Base Locale").description(
+    "Verify i18n files have no missing keys compared to base locale"
+  ).action(async (baseLocale = "en") => {
+    await I18nService.verify(baseLocale);
+  });
+}
+
+// src/commands/i18n/i18n.command.ts
+import { Command as Command2 } from "commander";
+var i18nCommand = new Command2().name("i18n").description("Manage and translate your i18n files").hook("preAction", () => {
+  return Workspace.logWorkspaceInfo();
+});
+createTranslateI18nCommand(i18nCommand);
+createVerifyI18nCommand(i18nCommand);
+
+// src/commands/license/activate/activate-license.command.ts
+import chalk5 from "chalk";
+import ora2 from "ora";
+import prompts3 from "prompts";
+import { z as z2 } from "zod";
+var schema2 = z2.object({
+  licenseKey: z2.string().min(1).max(32),
+  githubUsername: z2.string().min(1).max(64)
+});
+function createActivateLicenseCommand(parentCommand) {
+  return parentCommand.command("activate").description("Activate your license key for MakerKit").action(async () => {
+    const params = await prompts3([
+      {
+        type: "text",
+        name: "licenseKey",
+        message: `Enter your ${chalk5.cyan("License Key")}.`,
+        validate: (value) => {
+          if (value.length < 1) {
+            return `Please enter a valid license key`;
+          }
+          return true;
+        }
+      },
+      {
+        type: "text",
+        name: "githubUsername",
+        message: `Enter your ${chalk5.cyan("Github username")}.`,
+        validate: (value) => {
+          if (value.length < 1) {
+            return `Please enter a valid username`;
+          }
+          return true;
+        }
+      }
+    ]);
+    const spinner = ora2(`Activating license...`).start();
+    const onError = () => {
+      spinner.fail(`Failed to activate license`);
+      process.exit(1);
+    };
+    try {
+      const response = await activateLicense(schema2.parse(params));
+      if (!response.ok) {
+        return onError();
+      }
+      spinner.succeed(`License activated successfully`);
+    } catch (e) {
+      onError();
+    }
+  });
+}
+async function activateLicense(params) {
+  return fetch(`https://makerkit.dev/api/ls/license/activate`, {
+    method: "POST",
+    body: JSON.stringify(params)
+  });
+}
+
+// src/commands/license/license.command.ts
+import { Command as Command3 } from "commander";
+var licenseCommand = new Command3().name("license").description("Manage Licenses");
+createActivateLicenseCommand(licenseCommand);
+
+// src/commands/new/new.command.ts
+import { join as join4 } from "path";
+import chalk6 from "chalk";
+import { Command as Command4 } from "commander";
+import { execa } from "execa";
+import ora3 from "ora";
+import prompts4 from "prompts";
+var newCommand = new Command4().name("new").description("Initialize a new Makerkit project").action(async () => {
+  const choices = Object.values(KitsModel).map((kit2) => {
+    return {
+      title: kit2.name,
+      value: kit2.id
+    };
+  });
+  const { kit, name: projectName } = await prompts4([
+    {
+      type: "select",
+      name: "kit",
+      message: `Select the ${chalk6.cyan(`SaaS Kit`)} you want to clone`,
+      choices
+    },
+    {
+      type: "text",
+      name: "name",
+      message: `Enter your ${chalk6.cyan("Project Name")}.`
+    }
+  ]);
+  const { repository, name: kitName } = validateKit(kit);
+  const { confirm } = await prompts4([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Are you sure you want to clone ${chalk6.cyan(
+        kitName
+      )} to ${chalk6.cyan(projectName)}?`
+    }
+  ]);
+  if (!confirm) {
+    console.log("Aborting...");
+    process.exit(0);
+  }
+  await pullFromGithub(repository, kitName, projectName);
+  await installDependencies(projectName);
+});
+async function pullFromGithub(repository, kit, projectName) {
+  const spinner = ora3(`Cloning ${kit}...`).start();
+  try {
+    await execa("git", ["clone", repository, projectName]);
+    spinner.succeed(`Cloned ${kit} to ${projectName}...`);
+  } catch (e) {
+    console.error(e);
+    spinner.fail(`Failed to clone ${kit}`);
+    return Promise.reject(`Failed to clone ${kit}`);
+  }
+}
+async function installDependencies(projectName) {
+  const cwd = join4(process.cwd(), projectName);
+  const spinner = ora3(`Installing dependencies. Please wait...`).start();
+  try {
+    await execa("npm", ["install"], { cwd });
+    spinner.succeed(`Dependencies successfully installed!`);
+    console.log(
+      `\u{1F389} You can now get started. Open the project in your IDE and read the README.md file for more information.`
+    );
+  } catch (e) {
+    console.error(e);
+    spinner.fail(`Failed to install dependencies`);
+    return Promise.reject(`Failed to install dependencies`);
+  }
+}
+
+// src/commands/plugins/plugins-service.ts
+import chalk7 from "chalk";
+import { execaCommand } from "execa";
+import ora4 from "ora";
+import prompts5 from "prompts";
+var PluginsService = class {
+  static async install(pluginId) {
+    const action = "add" /* Add */;
+    const plugin = pluginId || await getPluginFromPrompts(action);
+    await initPluginCommand(plugin, action);
+  }
+  static async pull(pluginId) {
+    const action = "pull" /* Pull */;
+    const plugin = pluginId || await getPluginFromPrompts(action);
+    await initPluginCommand(plugin, action);
+  }
+};
+async function initPluginCommand(pluginId, action) {
+  const { id: kitId } = await Workspace.getKitMeta();
+  const plugin = validatePlugin(pluginId);
+  const kit = validateKit(kitId);
+  if (!kit.plugins.includes(plugin.id)) {
+    throw new Error(
+      `Plugin ${plugin.name} is not compatible with kit ${kit.name}`
+    );
+  }
+  const repository = buildPluginRepositoryName(kit.repository);
+  const verb = action === "add" /* Add */ ? "Installing" : "Updating";
+  console.log(
+    `${verb} ${chalk7.cyan(plugin.name)} to kit ${chalk7.cyan(
+      kit.name
+    )} using repo: ${repository} ...`
+  );
+  return executePluginCommand({
+    action,
+    repository,
+    branch: plugin.branch,
+    folder: `plugins/${plugin.branch}`
+  });
+}
+async function getPluginFromPrompts(action) {
+  const choices = Object.values(PluginsModel).map((plugin2) => {
+    return {
+      title: plugin2.name,
+      value: plugin2.id
+    };
+  });
+  const verb = action === "add" /* Add */ ? "install" : "update";
+  const { plugin } = await prompts5([
+    {
+      type: "select",
+      name: "plugin",
+      message: `Which ${chalk7.cyan("Plugin")} would you like to ${verb}?`,
+      choices
+    }
+  ]);
+  return plugin;
+}
+function buildPluginRepositoryName(repository) {
+  return repository + `-plugins.git`;
+}
+async function executePluginCommand({
+  action,
+  repository,
+  branch,
+  folder
+}) {
+  const verb = action === "add" /* Add */ ? "Installing" : "Updating";
+  const spinner = ora4(`${verb} plugin...`).start();
+  const commandString = `git subtree ${action} --prefix ${folder} ${repository} ${branch} --squash`;
+  try {
+    await execaCommand(commandString);
+    const verb2 = action === "add" /* Add */ ? "installed" : "updated";
+    spinner.succeed(`Plugin ${verb2} at ${folder}`);
+  } catch (e) {
+    console.error(e);
+    const verb2 = action === "add" /* Add */ ? "installation" : "update";
+    spinner.fail(`Plugin ${verb2} failed`);
+  }
+}
+
+// src/commands/plugins/install/install-plugin.command.ts
+function createInstallPluginCommand(parentCommand) {
+  return parentCommand.command("install").argument("[plugin-id]", "Plugin id").description("Install plugin").action(async (maybePluginId) => {
+    await PluginsService.install(maybePluginId);
+  });
+}
+
+// src/commands/plugins/list/list-plugins.command.ts
+import chalk8 from "chalk";
+function createListPluginsCommand(parentCommand) {
+  return parentCommand.command("list").description("List available plugins.").action(() => {
+    const kits = Object.values(KitsModel);
+    for (const kit of kits) {
+      console.log(`${chalk8.cyan(kit.name)}`);
+      if (!kit.plugins.length) {
+        console.log(chalk8.yellow(`- No plugins available`) + "\n");
+        continue;
+      }
+      for (const plugin of kit.plugins) {
+        const { name } = validatePlugin(plugin);
+        console.log(`- ${chalk8.green(name)}`);
+      }
+      console.log("");
+    }
+  });
+}
+
+// src/commands/plugins/update/update-plugin.command.ts
+function createUpdatePluginCommand(parentCommand) {
+  return parentCommand.command("update").argument("[plugin-id]", "Plugin id").description("Update plugin to the latest version").action(async (maybePluginId) => {
+    await PluginsService.pull(maybePluginId);
+  });
+}
+
+// src/commands/plugins/plugins.command.ts
+import { Command as Command5 } from "commander";
+var pluginsCommand = new Command5().name("plugins").description("List and install plugins.").hook("preAction", () => {
+  return Workspace.logWorkspaceInfo();
+});
+createListPluginsCommand(pluginsCommand);
+createInstallPluginCommand(pluginsCommand);
+createUpdatePluginCommand(pluginsCommand);
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+import { config } from "dotenv";
+config({
+  path: ".env.local"
+});
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+async function main() {
+  const program = new Command6().name("makerkit").description(
+    "Your SaaS Kit companion. Add plugins, manage migrations, and more."
+  ).version("-v, --version", "display the version number");
+  program.addCommand(newCommand).addCommand(pluginsCommand).addCommand(i18nCommand).addCommand(licenseCommand).addCommand(blogCommand);
+  program.parse();
+}
+void main();
+//# sourceMappingURL=index.js.map