@mayrlabs/setup-project 0.1.2 → 0.1.4

package/dist/index.js

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+
+/**
+ * MayR Labs CLI
+ * Build. Ship. Repeat intelligently.
+ *
+ * (c) 2026 MayR Labs
+ * https://mayrlabs.com
+ */
+
+"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
+));
+
+// src/index.ts
+var import_prompts9 = require("@clack/prompts");
+var import_picocolors = __toESM(require("picocolors"));
+var import_commander = require("commander");
+
+// src/services/husky.ts
+var import_prompts = require("@clack/prompts");
+
+// src/utils/pm.ts
+var import_execa = require("execa");
+async function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("yarn")) return "yarn";
+    if (userAgent.startsWith("pnpm")) return "pnpm";
+    if (userAgent.startsWith("bun")) return "bun";
+  }
+  return "npm";
+}
+async function installPackages(packages, dev = false) {
+  const pm = await getPackageManager();
+  const args = [];
+  if (pm === "npm") {
+    args.push("install");
+    if (dev) args.push("--save-dev");
+  } else if (pm === "yarn") {
+    args.push("add");
+    if (dev) args.push("-D");
+  } else if (pm === "pnpm") {
+    args.push("add");
+    if (dev) args.push("-D");
+  } else if (pm === "bun") {
+    args.push("add");
+    if (dev) args.push("-d");
+  }
+  await (0, import_execa.execa)(pm, [...args, ...packages]);
+}
+
+// src/services/husky.ts
+var import_execa2 = require("execa");
+var import_fs_extra = __toESM(require("fs-extra"));
+async function promptHusky(config) {
+  const hookType = await (0, import_prompts.select)({
+    message: "What pre-commit hook would you like to use?",
+    options: [
+      { value: "lint-staged", label: "lint-staged" },
+      { value: "custom", label: "Custom script" },
+      { value: "none", label: "None" }
+    ]
+  });
+  config.huskyHookType = hookType;
+  if (hookType === "lint-staged") {
+    config.lintStaged = true;
+  } else if (hookType === "custom") {
+    const script = await (0, import_prompts.text)({
+      message: "Enter your custom pre-commit script:",
+      placeholder: "npm test",
+      validate(value) {
+        if (value.length === 0) return "Value is required!";
+      }
+    });
+    config.huskyCustomScript = script;
+  }
+}
+async function installHusky(config) {
+  await installPackages(["husky"], true);
+  try {
+    await (0, import_execa2.execa)("npx", ["husky", "init"]);
+  } catch (e) {
+    await (0, import_execa2.execa)("npm", ["pkg", "set", "scripts.prepare=husky"]);
+    await (0, import_execa2.execa)("npm", ["run", "prepare"]);
+  }
+  if (config.huskyHookType === "lint-staged") {
+    await import_fs_extra.default.outputFile(".husky/pre-commit", "npx lint-staged\n", {
+      mode: 493
+    });
+  } else if (config.huskyHookType === "custom" && config.huskyCustomScript) {
+    await import_fs_extra.default.outputFile(".husky/pre-commit", `${config.huskyCustomScript}
+`, {
+      mode: 493
+    });
+  }
+}
+
+// src/services/formatter.ts
+var import_prompts2 = require("@clack/prompts");
+var import_fs_extra2 = __toESM(require("fs-extra"));
+async function promptFormatter(config) {
+  if (!config.formatterChoice) {
+    const formatter = await (0, import_prompts2.select)({
+      message: "Select a formatter:",
+      options: [
+        { value: "prettier", label: "Prettier" },
+        { value: "oxfmt", label: "Oxfmt" }
+      ]
+    });
+    config.formatterChoice = formatter;
+  }
+}
+async function installFormatter(config) {
+  if (config.formatterChoice === "prettier") {
+    await installPackages(["prettier"], true);
+    const configContent = {
+      semi: true,
+      singleQuote: true,
+      trailingComma: "all",
+      printWidth: 80,
+      tabWidth: 2
+    };
+    await import_fs_extra2.default.writeJson(".prettierrc", configContent, { spaces: 2 });
+  } else if (config.formatterChoice === "oxfmt") {
+    await installPackages(["oxfmt"], true);
+  }
+}
+
+// src/services/linter.ts
+var import_prompts3 = require("@clack/prompts");
+var import_fs_extra3 = __toESM(require("fs-extra"));
+async function promptLinter(config) {
+  if (!config.linterChoice) {
+    const linter = await (0, import_prompts3.select)({
+      message: "Select a linter:",
+      options: [
+        { value: "eslint", label: "ESLint" },
+        { value: "oxlint", label: "Oxlint" }
+      ]
+    });
+    config.linterChoice = linter;
+  }
+}
+async function installLinter(config) {
+  if (config.linterChoice === "eslint") {
+    await installPackages(["eslint"], true);
+    const configContent = {
+      extends: ["eslint:recommended"],
+      env: {
+        node: true,
+        es2021: true
+      },
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module"
+      }
+    };
+    await import_fs_extra3.default.writeJson(".eslintrc.json", configContent, { spaces: 2 });
+  } else if (config.linterChoice === "oxlint") {
+    await installPackages(["oxlint"], true);
+  }
+}
+
+// src/services/lint-staged.ts
+var import_prompts4 = require("@clack/prompts");
+var import_fs_extra4 = __toESM(require("fs-extra"));
+async function promptLintStaged(config) {
+  const lintExtensions = await (0, import_prompts4.multiselect)({
+    message: "Select extensions to lint:",
+    options: [
+      { value: "js", label: "js" },
+      { value: "ts", label: "ts" },
+      { value: "jsx", label: "jsx" },
+      { value: "tsx", label: "tsx" },
+      { value: "html", label: "html" },
+      { value: "vue", label: "vue" },
+      { value: "svelte", label: "svelte" }
+    ],
+    required: false
+  });
+  const formatExtensions = await (0, import_prompts4.multiselect)({
+    message: "Select extensions to format:",
+    options: [
+      { value: "md", label: "md" },
+      { value: "css", label: "css" },
+      { value: "scss", label: "scss" },
+      { value: "json", label: "json" },
+      { value: "yaml", label: "yaml" },
+      { value: "html", label: "html" },
+      { value: "js", label: "js" },
+      { value: "ts", label: "ts" },
+      { value: "jsx", label: "jsx" },
+      { value: "tsx", label: "tsx" },
+      { value: "vue", label: "vue" },
+      { value: "svelte", label: "svelte" }
+    ],
+    required: false
+  });
+  config.lintStagedLintExtensions = lintExtensions;
+  config.lintStagedFormatExtensions = formatExtensions;
+  if (lintExtensions.length > 0 && !config.linterChoice) {
+    await promptLinter(config);
+    config.linter = true;
+  }
+  if (formatExtensions.length > 0 && !config.formatterChoice) {
+    await promptFormatter(config);
+    config.formatter = true;
+  }
+}
+async function installLintStaged(config) {
+  await installPackages(["lint-staged"], true);
+  const lintStagedConfig = {};
+  const lintExts = config.lintStagedLintExtensions || [];
+  const formatExts = config.lintStagedFormatExtensions || [];
+  if (lintExts.length > 0) {
+    await installLinter(config);
+    const glob = `*.{${lintExts.join(",")}}`;
+    if (config.linterChoice === "oxlint") {
+      lintStagedConfig[glob] = ["npx oxlint --fix"];
+    } else {
+      lintStagedConfig[glob] = ["eslint --fix"];
+    }
+  }
+  if (formatExts.length > 0) {
+    await installFormatter(config);
+    const glob = `*.{${formatExts.join(",")}}`;
+    if (config.formatterChoice === "oxfmt") {
+      lintStagedConfig[glob] = ["npx oxfmt"];
+    } else {
+      lintStagedConfig[glob] = ["prettier --write"];
+    }
+  }
+  await import_fs_extra4.default.writeJson(".lintstagedrc", lintStagedConfig, { spaces: 2 });
+}
+
+// src/services/env.ts
+var import_prompts5 = require("@clack/prompts");
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+async function promptEnv(config) {
+  const variant = await (0, import_prompts5.select)({
+    message: "Which @t3-oss/env variant?",
+    options: [
+      { value: "@t3-oss/env-nextjs", label: "Next.js" },
+      { value: "@t3-oss/env-nuxt", label: "Nuxt" },
+      { value: "@t3-oss/env-core", label: "Core" }
+    ]
+  });
+  config.envVariant = variant;
+  const validator = await (0, import_prompts5.select)({
+    message: "Which validator?",
+    options: [
+      { value: "zod", label: "Zod" },
+      { value: "valibot", label: "Valibot" },
+      { value: "arktype", label: "Arktype" }
+    ]
+  });
+  config.envValidator = validator;
+  const installPresets = await (0, import_prompts5.confirm)({
+    message: "Install presets?"
+  });
+  config.envInstallPresets = installPresets;
+  if (installPresets) {
+    const presets = await (0, import_prompts5.multiselect)({
+      message: "Select preset to extend:",
+      options: [
+        { value: "netlify", label: "Netlify" },
+        { value: "vercel", label: "Vercel" },
+        { value: "neonVercel", label: "Neon (Vercel)" },
+        { value: "supabaseVercel", label: "Supabase (Vercel)" },
+        { value: "uploadThing", label: "UploadThing" },
+        { value: "render", label: "Render" },
+        { value: "railway", label: "Railway" },
+        { value: "fly.io", label: "Fly.io" },
+        { value: "upstashRedis", label: "Upstash Redis" },
+        { value: "coolify", label: "Coolify" },
+        { value: "vite", label: "Vite" },
+        { value: "wxt", label: "WXT" }
+      ],
+      required: false
+    });
+    config.envPresets = presets;
+  }
+  const split = await (0, import_prompts5.select)({
+    message: "Split or Joined env files?",
+    options: [
+      { value: "split", label: "Split (env/server.ts, env/client.ts)" },
+      { value: "joined", label: "Joined (env.ts)" }
+    ]
+  });
+  config.envSplit = split;
+  const location = await (0, import_prompts5.text)({
+    message: "Where should the environment files be created?",
+    initialValue: "src/lib",
+    placeholder: "src/lib"
+  });
+  config.envLocation = location;
+}
+async function installEnv(config) {
+  await installPackages([config.envVariant, config.envValidator], true);
+  if (config.envInstallPresets) {
+    const presetPackage = `@t3-oss/env-core/presets-${config.envValidator}`;
+    await installPackages([presetPackage], true);
+  }
+  const targetDir = config.envLocation;
+  await import_fs_extra5.default.ensureDir(targetDir);
+  const presetImport = config.envPresets && config.envPresets.length > 0 ? `// Presets: ${config.envPresets.join(", ")}
+` : "";
+  const content = `import { createEnv } from "${config.envVariant}";
+import { ${config.envValidator} } from "${config.envValidator}";
+
+${presetImport}`;
+  if (config.envSplit === "split") {
+    await import_fs_extra5.default.outputFile(
+      import_path.default.join(targetDir, "env/server.ts"),
+      `${content}
+// Server env definition
+export const env = createEnv({
+  server: {
+    // ...
+  },
+  experimental__runtimeEnv: process.env
+});`
+    );
+    await import_fs_extra5.default.outputFile(
+      import_path.default.join(targetDir, "env/client.ts"),
+      `${content}
+// Client env definition
+export const env = createEnv({
+  client: {
+    // ...
+  },
+  experimental__runtimeEnv: {
+    // ...
+  }
+});`
+    );
+  } else {
+    await import_fs_extra5.default.outputFile(
+      import_path.default.join(targetDir, "env.ts"),
+      `${content}
+// Joined env definition
+export const env = createEnv({
+  server: {
+    // ...
+  },
+  client: {
+    // ...
+  },
+  experimental__runtimeEnv: {
+    // ...
+  }
+});`
+    );
+  }
+}
+
+// src/services/test.ts
+var import_prompts6 = require("@clack/prompts");
+var import_fs_extra6 = __toESM(require("fs-extra"));
+async function promptTest(config) {
+  const runner = await (0, import_prompts6.select)({
+    message: "Select a test runner:",
+    options: [
+      { value: "vitest", label: "Vitest" },
+      { value: "jest", label: "Jest" }
+    ]
+  });
+  config.testRunner = runner;
+}
+async function installTest(config) {
+  if (config.testRunner === "vitest") {
+    await installPackages(["vitest"], true);
+    const configFile = "vitest.config.ts";
+    if (!await import_fs_extra6.default.pathExists(configFile)) {
+      await import_fs_extra6.default.outputFile(
+        configFile,
+        `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});
+`
+      );
+    }
+  } else if (config.testRunner === "jest") {
+    await installPackages(["jest", "ts-jest", "@types/jest"], true);
+    const configFile = "jest.config.js";
+    if (!await import_fs_extra6.default.pathExists(configFile)) {
+      await import_fs_extra6.default.outputFile(
+        configFile,
+        `/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};
+`
+      );
+    }
+  }
+}
+
+// src/services/editor-config.ts
+var import_prompts7 = require("@clack/prompts");
+var import_fs_extra7 = __toESM(require("fs-extra"));
+async function promptEditorConfig(config) {
+  const preset = await (0, import_prompts7.select)({
+    message: "Select EditorConfig preset:",
+    options: [
+      { value: "default", label: "Default (Spaces 2)" },
+      { value: "spaces4", label: "Spaces 4" },
+      { value: "tabs", label: "Tabs" }
+    ]
+  });
+  config.editorConfigPreset = preset;
+}
+async function installEditorConfig(config) {
+  let content = "root = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ninsert_final_newline = true\ntrim_trailing_whitespace = true\n";
+  if (config.editorConfigPreset === "default" || config.editorConfigPreset === "spaces2") {
+    content += "indent_style = space\nindent_size = 2\n";
+  } else if (config.editorConfigPreset === "spaces4") {
+    content += "indent_style = space\nindent_size = 4\n";
+  } else if (config.editorConfigPreset === "tabs") {
+    content += "indent_style = tab\n";
+  }
+  await import_fs_extra7.default.outputFile(".editorconfig", content);
+}
+
+// src/services/license.ts
+var import_prompts8 = require("@clack/prompts");
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+async function promptLicense(config) {
+  const name = await (0, import_prompts8.text)({
+    message: "License Holder Name:",
+    placeholder: "John Doe",
+    initialValue: config.authorName || ""
+  });
+  config.licenseName = name;
+  const email = await (0, import_prompts8.text)({
+    message: "License Holder Email:",
+    placeholder: "john@example.com"
+  });
+  config.licenseEmail = email;
+  const website = await (0, import_prompts8.text)({
+    message: "License Holder Website:",
+    placeholder: "https://example.com"
+  });
+  config.licenseWebsite = website;
+  const type = await (0, import_prompts8.select)({
+    message: "Select License Type:",
+    options: [
+      { value: "MIT", label: "MIT" },
+      { value: "ISC", label: "ISC" },
+      { value: "Apache-2.0", label: "Apache 2.0" },
+      { value: "UNLICENSED", label: "UNLICENSED" }
+    ]
+  });
+  config.licenseType = type;
+}
+async function installLicense(config) {
+  if (config.licenseType !== "UNLICENSED") {
+    const year = (/* @__PURE__ */ new Date()).getFullYear().toString();
+    const templatePath = import_path2.default.join(
+      __dirname,
+      "licenses",
+      `${config.licenseType}.txt`
+    );
+    if (await import_fs_extra8.default.pathExists(templatePath)) {
+      let licenseContent = await import_fs_extra8.default.readFile(templatePath, "utf-8");
+      licenseContent = licenseContent.replace(/{YEAR}/g, year);
+      licenseContent = licenseContent.replace(/{HOLDER}/g, config.licenseName);
+      licenseContent = licenseContent.replace(/{EMAIL}/g, config.licenseEmail);
+      licenseContent = licenseContent.replace(
+        /{WEBSITE}/g,
+        config.licenseWebsite
+      );
+      await import_fs_extra8.default.outputFile("LICENSE", licenseContent);
+    } else {
+      const simpleContent = `Copyright (c) ${year} ${config.licenseName}
+Licensed under ${config.licenseType}`;
+      await import_fs_extra8.default.outputFile("LICENSE", simpleContent);
+    }
+  }
+  if (await import_fs_extra8.default.pathExists("package.json")) {
+    const pkg = await import_fs_extra8.default.readJson("package.json");
+    pkg.license = config.licenseType;
+    if (config.licenseName) {
+      pkg.author = `${config.licenseName} <${config.licenseEmail}> (${config.licenseWebsite})`;
+    }
+    await import_fs_extra8.default.writeJson("package.json", pkg, { spaces: 2 });
+  }
+}
+
+// src/utils/git.ts
+var import_execa3 = require("execa");
+async function isGitRepository() {
+  try {
+    await (0, import_execa3.execa)("git", ["rev-parse", "--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isGitDirty() {
+  try {
+    const { stdout } = await (0, import_execa3.execa)("git", ["status", "--porcelain"]);
+    return stdout.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function commitChanges(message) {
+  await (0, import_execa3.execa)("git", ["add", "."]);
+  await (0, import_execa3.execa)("git", ["commit", "-m", message]);
+}
+
+// package.json
+var package_default = {
+  name: "@mayrlabs/setup-project",
+  version: "0.1.4",
+  description: "Interactive CLI to setup project tools",
+  private: false,
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "setup",
+    "cli",
+    "scaffold",
+    "husky",
+    "prettier",
+    "eslint"
+  ],
+  bin: {
+    "setup-project": "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "package.json"
+  ],
+  homepage: "https://github.com/MayR-Labs/mayrlabs-js/tree/main/packages/setup-project#readme",
+  bugs: {
+    url: "https://github.com/MayR-Labs/mayrlabs-js/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/MayR-Labs/mayrlabs-js.git",
+    directory: "packages/setup-project"
+  },
+  license: "MIT",
+  author: {
+    name: "Aghogho Meyoron",
+    email: "youngmayor.dev@gmail.com",
+    url: "https://mayrlabs.com"
+  },
+  type: "commonjs",
+  main: "dist/index.js",
+  scripts: {
+    build: "tsup",
+    demo: "tsx src/index.ts",
+    prepublishOnly: "npm run build"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.7.0",
+    commander: "^11.1.0",
+    execa: "^8.0.1",
+    "fs-extra": "^11.2.0",
+    picocolors: "^1.0.0",
+    zod: "^3.22.4"
+  },
+  devDependencies: {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.16",
+    tsup: "^8.5.1",
+    typescript: "^5.3.3"
+  }
+};
+
+// src/utils/logger.ts
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var LOG_DIR = ".mayrlabs/setup-project";
+var ERRORS_DIR = import_path3.default.join(LOG_DIR, "errors");
+async function logError(error) {
+  try {
+    await import_fs_extra9.default.ensureDir(ERRORS_DIR);
+    const gitignorePath = import_path3.default.join(LOG_DIR, ".gitignore");
+    if (!await import_fs_extra9.default.pathExists(gitignorePath)) {
+      await import_fs_extra9.default.outputFile(gitignorePath, "*\n");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const logFile = import_path3.default.join(ERRORS_DIR, `log-${timestamp}.txt`);
+    const errorMessage = error instanceof Error ? error.stack || error.message : String(error);
+    const logContent = `Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+Error:
+${errorMessage}
+`;
+    await import_fs_extra9.default.outputFile(logFile, logContent);
+    return logFile;
+  } catch (e) {
+    console.error("Failed to log error:", e);
+    return "";
+  }
+}
+
+// src/index.ts
+async function main() {
+  try {
+    (0, import_prompts9.intro)(import_picocolors.default.bgCyan(import_picocolors.default.black(" @mayrlabs/setup-project ")));
+    if (await isGitRepository()) {
+      if (await isGitDirty()) {
+        const shouldCommit = await (0, import_prompts9.confirm)({
+          message: "Your working directory is dirty. Would you like to commit changes before proceeding?"
+        });
+        if (shouldCommit) {
+          const message = await import("@clack/prompts").then(
+            (m) => m.text({
+              message: "Enter commit message:",
+              placeholder: "wip: pre-setup commit",
+              validate(value) {
+                if (value.length === 0) return "Commit message is required";
+              }
+            })
+          );
+          if (typeof message === "string") {
+            const s2 = (0, import_prompts9.spinner)();
+            s2.start("Committing changes...");
+            await commitChanges(message);
+            s2.stop("Changes committed.");
+          }
+        }
+      }
+    }
+    const tools = await (0, import_prompts9.multiselect)({
+      message: "Select tools to configure:",
+      options: [
+        { value: "husky", label: "Husky" },
+        { value: "formatter", label: "Formatter (Prettier/Oxfmt)" },
+        { value: "linter", label: "Linter (Eslint/Oxlint)" },
+        { value: "lint-staged", label: "Lint-staged" },
+        { value: "env", label: "Env Validation (@t3-oss/env)" },
+        { value: "test", label: "Test Runner (Vitest/Jest)" },
+        { value: "editorConfig", label: "EditorConfig" },
+        { value: "license", label: "License" }
+      ],
+      required: false
+    });
+    if ((0, import_prompts9.isCancel)(tools)) {
+      (0, import_prompts9.cancel)("Operation cancelled.");
+      process.exit(0);
+    }
+    const selectedTools = tools;
+    const config = {
+      husky: selectedTools.includes("husky"),
+      formatter: selectedTools.includes("formatter"),
+      linter: selectedTools.includes("linter"),
+      lintStaged: selectedTools.includes("lint-staged"),
+      env: selectedTools.includes("env"),
+      test: selectedTools.includes("test"),
+      editorConfig: selectedTools.includes("editorConfig"),
+      license: selectedTools.includes("license")
+    };
+    if (config.husky) await promptHusky(config);
+    if (config.formatter) await promptFormatter(config);
+    if (config.linter) await promptLinter(config);
+    if (config.lintStaged) await promptLintStaged(config);
+    if (config.env) await promptEnv(config);
+    if (config.test) await promptTest(config);
+    if (config.editorConfig) await promptEditorConfig(config);
+    if (config.license) await promptLicense(config);
+    let summary = "The following actions will be performed:\n\n";
+    if (config.husky) summary += "- Install and configure Husky\n";
+    if (config.formatter)
+      summary += `- Install and configure ${config.formatterChoice}
+`;
+    if (config.linter)
+      summary += `- Install and configure ${config.linterChoice}
+`;
+    if (config.lintStaged) summary += "- Install and configure Lint-staged\n";
+    if (config.env) summary += "- Install and configure @t3-oss/env\n";
+    if (config.test)
+      summary += `- Install and configure ${config.testRunner}
+`;
+    if (config.editorConfig) summary += "- Create .editorconfig\n";
+    if (config.license) summary += `- Create LICENSE (${config.licenseType})
+`;
+    (0, import_prompts9.note)(summary, "Configuration Summary");
+    const proceed = await (0, import_prompts9.confirm)({
+      message: "Do you want to proceed with the installation?"
+    });
+    if (!proceed || (0, import_prompts9.isCancel)(proceed)) {
+      (0, import_prompts9.cancel)("Installation cancelled. Configuration saved.");
+      process.exit(0);
+    }
+    const s = (0, import_prompts9.spinner)();
+    if (config.husky) {
+      s.start("Setting up Husky...");
+      await installHusky(config);
+      s.stop("Husky setup complete.");
+    }
+    if (config.formatter) {
+      s.start(`Setting up ${config.formatterChoice}...`);
+      await installFormatter(config);
+      s.stop(`${config.formatterChoice} setup complete.`);
+    }
+    if (config.linter) {
+      s.start(`Setting up ${config.linterChoice}...`);
+      await installLinter(config);
+      s.stop(`${config.linterChoice} setup complete.`);
+    }
+    if (config.lintStaged) {
+      s.start("Setting up Lint-staged...");
+      await installLintStaged(config);
+      s.stop("Lint-staged setup complete.");
+    }
+    if (config.env) {
+      s.start("Setting up Env Validation...");
+      await installEnv(config);
+      s.stop("Env Validation setup complete.");
+    }
+    if (config.test) {
+      s.start(`Setting up ${config.testRunner}...`);
+      await installTest(config);
+      s.stop(`${config.testRunner} setup complete.`);
+    }
+    if (config.editorConfig) {
+      s.start("Creating .editorconfig...");
+      await installEditorConfig(config);
+      s.stop(".editorconfig created.");
+    }
+    if (config.license) {
+      s.start("Creating LICENSE...");
+      await installLicense(config);
+      s.stop("LICENSE created.");
+    }
+    (0, import_prompts9.outro)(import_picocolors.default.green("Setup complete!"));
+  } catch (error) {
+    const logPath = await logError(error);
+    (0, import_prompts9.outro)(import_picocolors.default.red(`
+Something went wrong!
+Error log saved to: ${logPath}`));
+    process.exit(1);
+  }
+}
+import_commander.program.name("setup-project").description("Interactive setup for common project tools").version(package_default.version).action(main);
+import_commander.program.parse();
+
+/**
+ * Built with discipline by MayR Labs.
+ * Software should feel intentional.
+ */
+