create-vitnode-app 0.0.1-canary.0

package/dist/src/helpers/install-dependencies.js

@@ -0,0 +1,71 @@
+import { spawn } from "node:child_process";
+import consoleColor from "picocolors";
+import { getOnline } from "./is-online.js";
+function printInstallErrorSuggestions(stderr, color) {
+    if (stderr.includes("ENOTFOUND") || stderr.includes("network")) {
+        console.error(color.yellow("💡 Network error detected. Please check your internet connection."));
+    }
+    else if (stderr.includes("EACCES") ||
+        stderr.includes("permission denied")) {
+        console.error(color.yellow("💡 Permission error detected. Try running with elevated privileges or check file permissions."));
+    }
+    else if (stderr.includes("ENOSPC")) {
+        console.error(color.yellow("💡 Disk space error detected. Please free up some disk space."));
+    }
+    else if (stderr.includes("ERR_PNPM_PEER_DEP_ISSUES")) {
+        console.error(color.yellow("💡 Peer dependency issues detected. Consider using --force flag or resolve conflicts manually."));
+    }
+}
+export const installDependencies = async ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split("@")[0];
+    const isOnline = await getOnline();
+    const args = ["install"];
+    if (!isOnline) {
+        console.log(consoleColor.yellow("You appear to be offline.\nFalling back to the local cache."));
+        args.push("--offline");
+    }
+    return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        const child = spawn(packageManager, args, {
+            stdio: "pipe",
+            cwd,
+            shell: true,
+            env: {
+                ...process.env,
+                ADBLOCK: "1",
+                NODE_ENV: "development",
+                DISABLE_OPENCOLLECTIVE: "1",
+            },
+        });
+        child.stdout?.on("data", (data) => {
+            const output = data.toString();
+            stdout += output;
+        });
+        child.stderr?.on("data", (data) => {
+            const output = data.toString();
+            stderr += output;
+        });
+        child.on("close", code => {
+            if (code !== 0) {
+                console.error(consoleColor.red(`\n❌ Installation failed with exit code: ${code}`));
+                if (stderr) {
+                    console.error(consoleColor.red("Error output:"));
+                    console.error(stderr);
+                }
+                if (stdout) {
+                    console.log(consoleColor.yellow("Standard output:"));
+                    console.log(stdout);
+                }
+                printInstallErrorSuggestions(stderr, consoleColor);
+                reject(new Error(`Failed to install dependencies using ${packageManager}. Exit code: ${code}\n${stderr || stdout}`));
+                return;
+            }
+            resolve();
+        });
+        child.on("error", error => {
+            console.error(consoleColor.red(`❌ Failed to start ${packageManager}:`), error.message);
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}`));
+        });
+    });
+};

package/dist/src/helpers/is-folder-empty.js

@@ -0,0 +1,48 @@
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import colors from "picocolors";
+export function isFolderEmpty(root, name) {
+    const validFiles = [
+        ".DS_Store",
+        ".git",
+        ".gitattributes",
+        ".gitignore",
+        ".gitlab-ci.yml",
+        ".hg",
+        ".hgcheck",
+        ".hgignore",
+        ".idea",
+        ".npmignore",
+        ".travis.yml",
+        "LICENSE",
+        "Thumbs.db",
+        "docs",
+        "mkdocs.yml",
+        "npm-debug.log",
+        "yarn-debug.log",
+        "yarn-error.log",
+        "yarnrc.yml",
+        ".yarn",
+    ];
+    const conflicts = readdirSync(root).filter(file => !(validFiles.includes(file) || file.endsWith(".iml")));
+    if (conflicts.length > 0) {
+        console.log(`The directory ${colors.green(name)} contains files that could conflict:\n`);
+        for (const file of conflicts) {
+            try {
+                const stats = lstatSync(join(root, file));
+                if (stats.isDirectory()) {
+                    console.log(`${colors.blue(file)}/`);
+                }
+                else {
+                    console.log(file);
+                }
+            }
+            catch {
+                console.log(file);
+            }
+        }
+        console.log("\nEither try using a new directory name, or remove the files listed above.\n");
+        return false;
+    }
+    return true;
+}

package/dist/src/helpers/is-online.js

@@ -0,0 +1,38 @@
+import { execSync } from "node:child_process";
+import { lookup } from "node:dns/promises";
+import { URL } from "node:url";
+function getProxy() {
+    if (process.env.https_proxy) {
+        return process.env.https_proxy;
+    }
+    try {
+        const httpsProxy = execSync("npm config get https-proxy").toString().trim();
+        return httpsProxy !== "null" ? httpsProxy : undefined;
+    }
+    catch {
+        return;
+    }
+}
+export async function getOnline() {
+    try {
+        await lookup("registry.yarnpkg.com");
+        return true;
+    }
+    catch {
+        const proxy = getProxy();
+        if (!proxy) {
+            return false;
+        }
+        const { hostname } = new URL(proxy);
+        if (!hostname) {
+            return false;
+        }
+        try {
+            await lookup(hostname);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/src/helpers/is-writeable.js

@@ -0,0 +1,11 @@
+import { W_OK } from "node:constants";
+import { access } from "node:fs/promises";
+export async function isWriteable(directory) {
+    try {
+        await access(directory, W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/helpers/packages-json.js

@@ -0,0 +1 @@
+export {};

package/dist/src/helpers/validate-pkg.js

@@ -0,0 +1,14 @@
+import validateProjectName from "validate-npm-package-name";
+export const validateNpmName = ({ name, }) => {
+    const nameValidation = validateProjectName(name);
+    if (nameValidation.validForNewPackages) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        problems: [
+            ...(nameValidation.errors ?? []),
+            ...(nameValidation.warnings ?? []),
+        ],
+    };
+};

package/dist/src/helpers/with-If.js

@@ -0,0 +1 @@
+export const withIf = (cond, obj) => (cond ? obj : {});

package/dist/src/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { input } from "@inquirer/prompts";
+import { Command, Option } from "commander";
+import { basename, resolve } from "node:path";
+import color from "picocolors";
+import { createVitNode } from "./create/create-vitnode.js";
+import { packageJson } from "./helpers/get-package-json.js";
+import { validateNpmName } from "./helpers/validate-pkg.js";
+import { createPlugin } from "./plugin/index.js";
+import { createQuestionsCli } from "./questions.js";
+import { validationProject } from "./validation.js";
+const [major] = process.versions.node.split(".").map(Number);
+if (major < 20) {
+    console.error(color.red(`\nError: VitNode requires Node.js version 20 or higher.\nYou are currently using Node.js ${process.versions.node}\n`));
+    process.exit(1);
+}
+process.on("uncaughtException", (error) => {
+    if (error.name === "ExitPromptError") {
+        console.log(color.dim("👋 VitNode setup cancelled - see you next time!"));
+        process.exit(0);
+    }
+    console.error(color.red("An unexpected error occurred:"));
+    console.error(color.red(error.stack ?? error.message));
+    process.exit(1);
+});
+const init = async () => {
+    let projectPath = "";
+    const program = new Command()
+        .version(packageJson.version ?? "0.1.0")
+        .argument("[project-directory]")
+        .usage(`${color.green("[project-directory]")} [options]`)
+        .action(name => {
+        projectPath = name;
+    });
+    program.addOption(new Option("--package-manager <package-manager>", "Specify the package manager to use").choices(["npm", "pnpm", "bun"]));
+    program.option("--eslint", "Initialize with ESLint & Prettier config.");
+    program.option("--skip-install", "Skip installing packages after initializing the project.");
+    program.addOption(new Option("--mode <mode>", "What type of app do you want to create?").choices(["singleApp", "apiMonorepo", "onlyApi"]));
+    program.option("--monorepo", "Create project with monorepo structure.");
+    program.option("--docker", "Initialize with Docker support.");
+    program.option("--plugin", "Create a plugin.");
+    program.parse(process.argv);
+    const opts = program.opts();
+    if (opts.plugin) {
+        await createPlugin({ projectPath, program });
+        return;
+    }
+    if (!projectPath) {
+        projectPath = await input({
+            message: "What is your project named?",
+            default: "my-vitnode",
+            validate: (name) => {
+                const validation = validateNpmName({ name: basename(resolve(name)) });
+                if (validation.valid)
+                    return true;
+                return `Invalid project name: ${validation.problems[0]}`;
+            },
+        });
+    }
+    const { appName, root } = await validationProject(projectPath);
+    const options = await createQuestionsCli(program);
+    await createVitNode({
+        appName,
+        root,
+        ...options,
+    });
+};
+await init();

package/dist/src/plugin/create/add-plugin-to-workspace.js

@@ -0,0 +1,74 @@
+import { readdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+const writeJson = async (path, data) => writeFile(path, JSON.stringify(data, null, 2) + "\n");
+const findPackageJsonFiles = async (dir, results = []) => {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.name === "node_modules" || entry.name === "dist") {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await findPackageJsonFiles(fullPath, results);
+            }
+            else if (entry.name === "package.json") {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch {
+    }
+    return results;
+};
+export const addPluginToWorkspace = async ({ packageManager, pluginName, pluginPath, rootPath, }) => {
+    const packageJsonFiles = await findPackageJsonFiles(rootPath);
+    const pluginParentDir = dirname(pluginPath);
+    for (const packageJsonPath of packageJsonFiles) {
+        if (packageJsonPath === join(pluginPath, "package.json")) {
+            continue;
+        }
+        const packageDir = dirname(dirname(packageJsonPath));
+        if (packageDir === pluginParentDir) {
+            continue;
+        }
+        try {
+            const content = await readFile(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            const hasVitnodeCore = pkg.dependencies?.["@vitnode/core"] ??
+                pkg.devDependencies?.["@vitnode/core"];
+            if (!hasVitnodeCore) {
+                continue;
+            }
+            let workspaceReference;
+            switch (packageManager) {
+                case "bun":
+                    workspaceReference = "workspace:*";
+                    break;
+                case "npm":
+                    workspaceReference = "*";
+                    break;
+                case "pnpm":
+                    workspaceReference = "workspace:*";
+                    break;
+                case "yarn":
+                    workspaceReference = "workspace:*";
+                    break;
+                default:
+                    workspaceReference = "workspace:*";
+            }
+            pkg.dependencies ??= {};
+            pkg.dependencies[pluginName] = workspaceReference;
+            pkg.dependencies = Object.keys(pkg.dependencies)
+                .sort()
+                .reduce((acc, key) => {
+                acc[key] = pkg.dependencies?.[key] ?? "";
+                return acc;
+            }, {});
+            await writeJson(packageJsonPath, pkg);
+        }
+        catch {
+            continue;
+        }
+    }
+};

package/dist/src/plugin/create/create-package-json.js

@@ -0,0 +1,54 @@
+import { writeFile } from "fs/promises";
+import { versionsPackageJson } from "../../create/package-versions.js";
+import { getVitnodePackageVersion } from "../../helpers/get-vitnode-package-version.js";
+import { withIf } from "../../helpers/with-If.js";
+import { pluginPackageExports } from "./route-templates.js";
+const writeJson = async (path, data) => writeFile(path, JSON.stringify(data, null, 2));
+export const createPluginPackageJSON = async ({ pluginName, pluginPath, eslint, }) => {
+    const vitnodeVersionRange = await getVitnodePackageVersion();
+    const pluginPkg = {
+        name: pluginName,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+            "build:plugins": "vitnode build",
+            dev: "vitnode dev",
+            "dev:email": "email dev --dir src/emails",
+            ...withIf(eslint, {
+                lint: "turbo lint",
+                "lint:fix": "turbo lint:fix",
+            }),
+        },
+        exports: pluginPackageExports(),
+        dependencies: {
+            "@hono/zod-openapi": versionsPackageJson.honoZodOpenapi,
+            "@vitnode/core": vitnodeVersionRange,
+            "drizzle-kit": versionsPackageJson.drizzleKit,
+            "drizzle-orm": versionsPackageJson.drizzleOrm,
+            hono: versionsPackageJson.hono,
+            "lucide-react": versionsPackageJson.lucide,
+            react: versionsPackageJson.react,
+            "react-dom": versionsPackageJson.reactDom,
+            "react-email": versionsPackageJson.reactEmail,
+            "react-hook-form": versionsPackageJson.rhf,
+            sonner: versionsPackageJson.sonner,
+            "use-intl": versionsPackageJson.useIntl,
+            zod: versionsPackageJson.zod,
+        },
+        devDependencies: {
+            "@react-email/ui": versionsPackageJson.reactEmailUi,
+            "@swc/cli": versionsPackageJson.swcCli,
+            "@swc/core": versionsPackageJson.swcCore,
+            "@types/react": versionsPackageJson.typesReact,
+            "@types/react-dom": versionsPackageJson.typesReactDom,
+            "@vitnode/config": vitnodeVersionRange,
+            ...withIf(eslint, {
+                eslint: versionsPackageJson.eslint,
+            }),
+            "tsc-alias": versionsPackageJson.tscAlias,
+            typescript: versionsPackageJson.typescript,
+        },
+    };
+    await writeJson(`${pluginPath}/package.json`, pluginPkg);
+};

package/dist/src/plugin/create/create-plugin-vitnode.js

@@ -0,0 +1,80 @@
+import { existsSync } from "fs";
+import { cp, mkdir, rename, writeFile } from "fs/promises";
+import ora from "ora";
+import { dirname, join } from "path";
+import color from "picocolors";
+import { fileURLToPath } from "url";
+import { getPackageManagerFromRoot } from "../../helpers/get-package-manager-from-root.js";
+import { installDependencies } from "../../helpers/install-dependencies.js";
+import { isFolderEmpty } from "../../helpers/is-folder-empty.js";
+import { addPluginToWorkspace } from "./add-plugin-to-workspace.js";
+import { createPluginPackageJSON } from "./create-package-json.js";
+import { pluginRouteScaffold } from "./route-templates.js";
+const writePluginRouteScaffold = async ({ pluginName, pluginPath, }) => {
+    const files = pluginRouteScaffold(pluginName);
+    await Promise.all(Object.keys(files).map(async (file) => mkdir(dirname(join(pluginPath, file)), { recursive: true })));
+    await Promise.all(Object.entries(files).map(async ([file, contents]) => writeFile(join(pluginPath, file), contents, "utf-8")));
+};
+export const createPluginVitNode = async ({ pluginPath, pluginName, install, eslint, }) => {
+    const packageManager = getPackageManagerFromRoot(process.cwd());
+    const spinner = ora(`Creating a new VitNode plugin in ${color.green(pluginPath)}. Using ${color.green(packageManager)}...`).start();
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const templatePath = join(__dirname, "..", "..", "..", "..", "copy-of-vitnode-plugin", "root");
+    if (!existsSync(templatePath)) {
+        spinner.fail(`\n${color.red("Error!")} Template path ${color.cyan(templatePath)} does not exist.`);
+        process.exit(1);
+    }
+    await mkdir(pluginPath, { recursive: true });
+    if (!isFolderEmpty(pluginPath, pluginName)) {
+        process.exit(1);
+    }
+    spinner.text = "Preparing the plugin structure...";
+    await cp(templatePath, pluginPath, { recursive: true });
+    const npmIgnoreTemplatePath = join(pluginPath, "npmignore.template");
+    const dotNpmIgnorePath = join(pluginPath, ".npmignore");
+    if (existsSync(npmIgnoreTemplatePath)) {
+        await rename(npmIgnoreTemplatePath, dotNpmIgnorePath);
+    }
+    spinner.text = "Writing the plugin's first route...";
+    await writePluginRouteScaffold({ pluginName, pluginPath });
+    spinner.text = "Creating package.json...";
+    await createPluginPackageJSON({
+        pluginName,
+        pluginPath,
+        eslint,
+    });
+    if (eslint) {
+        spinner.text = "Setting up ESLint...";
+        const templateEslintPath = join(__dirname, "..", "..", "..", "..", "copy-of-vitnode-app", "eslint-react");
+        if (!existsSync(templateEslintPath)) {
+            spinner.fail(`\n${color.red("Error!")} ESLint template path ${color.cyan(templateEslintPath)} does not exist.`);
+            process.exit(1);
+        }
+        await cp(templateEslintPath, pluginPath, { recursive: true });
+    }
+    let rootPath = process.cwd();
+    let currentDir = rootPath;
+    while (currentDir !== dirname(currentDir)) {
+        if (existsSync(join(currentDir, "turbo.json"))) {
+            rootPath = currentDir;
+            break;
+        }
+        currentDir = dirname(currentDir);
+    }
+    spinner.text = "Adding plugin to workspace packages...";
+    await addPluginToWorkspace({
+        packageManager,
+        pluginName,
+        pluginPath,
+        rootPath,
+    });
+    if (install) {
+        spinner.text = "Installing dependencies...";
+        await installDependencies({
+            packageManager,
+            cwd: pluginPath,
+        });
+    }
+    spinner.succeed(`${color.green("Success!")} Created ${color.cyan(pluginName)} at ${color.cyan(pluginPath)}`);
+};

package/dist/src/plugin/create/route-templates.js

@@ -0,0 +1,144 @@
+export const routeSlugFor = (pluginName) => pluginName.includes("/")
+    ? pluginName.slice(pluginName.indexOf("/") + 1)
+    : pluginName;
+export const pluginRoutesTemplate = (pluginName) => {
+    const slug = routeSlugFor(pluginName);
+    return `import { definePluginRoutes, lazy, page } from "@vitnode/core/routing";
+
+/**
+ * The routes this plugin contributes to whatever app installs it.
+ *
+ * Browser-safe data: a path, and the module that renders it. \`lazy\` keeps that
+ * \`import()\` a literal the bundler can follow *without running it*, so your page
+ * gets a chunk of its own and is fetched when somebody navigates to it - not
+ * before. Never import a page into this file: a component named here is in the
+ * initial bundle of every page on the site, which is why VitNode refuses one.
+ *
+ * Your page is never copied into the application either. The app holds one static
+ * import of this tree, and nothing else.
+ *
+ * Add a route by adding a \`page()\`. \`path\` is the public URL, written in
+ * VitNode's own spelling: a dynamic segment is \`:id\`, never Next's \`[id]\` and
+ * never TanStack's \`$id\`. To nest pages inside a shared frame, wrap them in a
+ * \`layout()\` and give each child a path relative to it.
+ */
+export const routes = definePluginRoutes([
+  page("/${slug}", {
+    component: lazy(() => import("./pages/home-page")),
+  }),
+]);
+`;
+};
+export const pluginRouteModuleTemplate = (pluginName) => `import { useTranslations } from "use-intl";
+
+/**
+ * The page \`routes.ts\` declares.
+ *
+ * Keep it framework-neutral. This module is compiled into the package's own
+ * \`dist\` and imported by whichever app installed the plugin, so anything from
+ * a router or a host-bound i18n package pins the plugin to one kind of host.
+ * \`use-intl\` - which is what VitNode itself renders through - and plain JSX are
+ * pinned to neither.
+ *
+ * No \`<main>\`: the application shell owns the document's one \`main\` landmark,
+ * and a page that renders a second gives a screen reader two to choose between.
+ * A page owns its container - width, padding, vertical rhythm - and nothing
+ * above it.
+ *
+ * To give this route a loader, page metadata or a breadcrumb, add a \`route\`
+ * export beside the default one:
+ *
+ *     import { definePluginRoute } from "@vitnode/core/routing";
+ *
+ *     export const route = definePluginRoute({
+ *       load: ({ context, params }) => fetchThing(context.locale, params.id),
+ *       head: ({ loaderData }) => ({ title: loaderData?.title }),
+ *     });
+ */
+const HomePage = () => {
+  const t = useTranslations("${pluginName}");
+
+  return (
+    <div className="container mx-auto flex max-w-2xl flex-col gap-4 p-4">
+      <h1 className="text-2xl font-semibold tracking-tight text-balance">
+        {t("home.title")}
+      </h1>
+
+      <p className="text-muted-foreground leading-relaxed text-pretty">
+        {t("home.desc")}
+      </p>
+    </div>
+  );
+};
+
+export default HomePage;
+`;
+export const pluginMessagesTemplate = (pluginName) => `${JSON.stringify({
+    [pluginName]: {
+        home: {
+            desc: "This page ships inside the plugin and is served by the app that installed it.",
+            title: "Hello from your plugin",
+        },
+    },
+}, null, 2)}\n`;
+export const pluginMessagesBarrelTemplate = () => `import type { LocaleMessagesMap } from "@vitnode/core/lib/i18n/types";
+
+/**
+ * Every language this plugin ships. Add a file next to this one and a line here
+ * to add another; apps pick it up with no copy step, because they read this
+ * package's own \`dist\` rather than a copy of it.
+ */
+const messages: LocaleMessagesMap = {
+  en: async () => await import("./en.json", { with: { type: "json" } }),
+};
+
+export default messages;
+`;
+export const pluginVariableName = (pluginName) => {
+    const camel = routeSlugFor(pluginName)
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((part, index) => index === 0 ? part : `${part[0].toUpperCase()}${part.slice(1)}`)
+        .join("");
+    const safe = /^[A-Za-z]/.test(camel) ? camel : `vitnode${camel}`;
+    const stem = safe.replace(/plugin$/i, "");
+    return `${stem === "" ? safe : stem}Plugin`;
+};
+export const pluginConfigTemplate = (pluginName) => `import { buildPlugin } from "@vitnode/core/lib/plugin";
+
+import messages from "./locales";
+import { routes } from "./routes";
+
+/**
+ * This plugin, as an application registers it.
+ *
+ * \`pluginId\` is the package name, and that is not a convention - it is how this
+ * plugin's route tree is imported (\`${pluginName}/routes\`) and how its messages
+ * are namespaced. The two cannot drift because they are one string.
+ *
+ * Add this to an app's \`src/vitnode.config.ts\` \`plugins\` array. A plugin that
+ * is installed but not listed there contributes nothing - no directory is ever
+ * scanned - so this is the only switch.
+ */
+export const ${pluginVariableName(pluginName)} = () =>
+  buildPlugin({
+    pluginId: "${pluginName}",
+    messages,
+    routes,
+  });
+`;
+export const pluginPackageExports = () => ({
+    "./locales/*.json": "./src/locales/*.json",
+    "./*": {
+        import: "./dist/src/*.js",
+        types: "./dist/src/*.d.ts",
+        default: "./dist/src/*.js",
+    },
+});
+export const pluginRouteScaffold = (pluginName) => ({
+    "src/config.tsx": pluginConfigTemplate(pluginName),
+    "src/locales/en.json": pluginMessagesTemplate(pluginName),
+    "src/locales/index.ts": pluginMessagesBarrelTemplate(),
+    "src/pages/home-page.tsx": pluginRouteModuleTemplate(pluginName),
+    "src/routes.ts": pluginRoutesTemplate(pluginName),
+});

package/dist/src/plugin/index.js

@@ -0,0 +1,29 @@
+import { input } from "@inquirer/prompts";
+import { basename, resolve } from "node:path";
+import { validateNpmName } from "../helpers/validate-pkg.js";
+import { createPluginVitNode } from "./create/create-plugin-vitnode.js";
+import { createPluginQuestionsCli } from "./questions.js";
+import { validationProjectForPlugin } from "./validation.js";
+export const createPlugin = async ({ program, projectPath, }) => {
+    let name = projectPath;
+    if (!name) {
+        name = await input({
+            message: "What is your plugin named?",
+            default: "my-vitnode-plugin",
+            validate: (name) => {
+                const validation = validateNpmName({ name: basename(resolve(name)) });
+                if (validation.valid)
+                    return true;
+                return `Invalid plugin name: ${validation.problems[0]}`;
+            },
+        });
+    }
+    const { pluginName, pluginPath, eslint } = await validationProjectForPlugin(name);
+    const options = await createPluginQuestionsCli(program);
+    await createPluginVitNode({
+        pluginName,
+        pluginPath,
+        eslint,
+        ...options,
+    });
+};

package/dist/src/plugin/questions.js

@@ -0,0 +1,14 @@
+import { confirm } from "@inquirer/prompts";
+import color from "picocolors";
+export const createPluginQuestionsCli = async (program) => {
+    const optionsFromProgram = program.opts();
+    const options = {
+        install: !optionsFromProgram.skipInstall,
+    };
+    if (optionsFromProgram.skipInstall === undefined) {
+        options.install = await confirm({
+            message: `Would you like to ${color.blue("Install dependencies")}?`,
+        });
+    }
+    return options;
+};