create-krispya 0.6.0 → 0.7.0

package/dist/cli.mjs

@@ -1,3004 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'module';
-import { cwd } from 'process';
-import { join, dirname, resolve } from 'path';
-import { access, constants, readFile, mkdir, writeFile, rm, readdir, unlink } from 'fs/promises';
-import { constants as constants$1 } from 'fs';
-import { Command } from 'commander';
-import * as p from '@clack/prompts';
-import color from 'chalk';
-import { fetch } from 'undici';
-import { spawn } from 'child_process';
-import { g as getBaseTemplate, a as getLanguageFromTemplate, b as generateRandomName, d as detectTooling, c as generateAiFiles, A as ALL_AI_PLATFORMS, e as generateVscodeFiles, f as generateTypescriptConfigPackage, h as generateOxlintConfigPackage, i as generateEslintConfigPackage, j as generateOxfmtConfigPackage, k as generatePrettierConfigPackage, p as parseWorkspaceYamlContent, l as getLatestNpmVersion, m as generate, n as getLatestPnpmVersion, o as getLatestYarnVersion, q as getLatestNpmCliVersion, r as getLatestNodeVersion, s as AI_PLATFORM_LABELS, t as AI_PLATFORM_HINTS, v as validatePackageName } from './chunks/index.mjs';
-import Conf from 'conf';
-
-const editorNames = {
-  cursor: "Cursor",
-  code: "VS Code",
-  webstorm: "WebStorm",
-  skip: "Skip"
-};
-function openInEditor(editor, path, reuseWindow) {
-  return new Promise((resolve, reject) => {
-    const isWindows = process.platform === "win32";
-    const useReuseFlag = reuseWindow && (editor === "cursor" || editor === "code");
-    const args = useReuseFlag ? ["-r", path] : [path];
-    const child = isWindows ? spawn(`${editor} ${useReuseFlag ? "-r " : ""}"${path}"`, {
-      detached: true,
-      stdio: "ignore",
-      shell: true
-    }) : spawn(editor, args, {
-      detached: true,
-      stdio: "ignore"
-    });
-    child.on("error", reject);
-    child.unref();
-    setTimeout(resolve, 100);
-  });
-}
-
-function formatConfigSummary(options, inherited) {
-  const lines = [];
-  const VALUE_COL = 27;
-  const formatRow = (label, value, isInherited = false, indent = "") => {
-    const fullLabel = indent + label;
-    const dotCount = Math.max(1, VALUE_COL - fullLabel.length - 1);
-    const dots = color.gray(".".repeat(dotCount));
-    const displayValue = isInherited ? `${value} \u{1F512}` : value;
-    return `${indent}${label} ${dots} ${displayValue}`;
-  };
-  const formatLanguage = (lang) => {
-    return lang === "typescript" ? "TypeScript" : lang === "javascript" ? "JavaScript" : lang;
-  };
-  const projectType = options.projectType ?? "app";
-  const baseTemplate = options.template ? getBaseTemplate(options.template) : "vanilla";
-  if (baseTemplate === "react") {
-    lines.push(formatRow("Framework", "React"));
-  } else if (baseTemplate === "r3f") {
-    lines.push(formatRow("Framework", "React Three Fiber"));
-  }
-  const language = options.template ? getLanguageFromTemplate(options.template) : "typescript";
-  lines.push(formatRow("Language", formatLanguage(language)));
-  if (projectType === "library") {
-    lines.push(formatRow("Bundler", options.libraryBundler ?? "unbuild"));
-  } else {
-    lines.push(formatRow("Bundler", "vite"));
-  }
-  const nodeVersionInherited = inherited?.nodeVersion !== void 0;
-  lines.push(formatRow("Node version", options.nodeVersion || "latest", nodeVersionInherited));
-  const pmInherited = inherited?.packageManager !== void 0;
-  lines.push(formatRow("Package manager", options.packageManager || "pnpm", pmInherited));
-  if (options.packageManager === "pnpm") {
-    const versionManaged = options.pnpmManageVersions ? "yes" : "no";
-    const pnpmVersionInherited = inherited?.pnpmManageVersions !== void 0;
-    lines.push(formatRow("\u21B3 Version managed", versionManaged, pnpmVersionInherited, ""));
-  }
-  if (options.linter) {
-    const linterInherited = inherited?.linter !== void 0;
-    lines.push(formatRow("Linter", options.linter, linterInherited));
-  }
-  if (options.formatter) {
-    const formatterInherited = inherited?.formatter !== void 0;
-    lines.push(formatRow("Formatter", options.formatter, formatterInherited));
-  }
-  const testing = options.testing ?? (projectType === "library" ? "vitest" : "none");
-  lines.push(formatRow("Testing", testing));
-  if (!inherited) {
-    const configStrategy = options.configStrategy ?? "stealth";
-    lines.push(formatRow("Config strategy", configStrategy));
-  }
-  if (options.template && getBaseTemplate(options.template) === "r3f") {
-    const integrationNames = [
-      options.drei && "drei",
-      options.handle && "handle",
-      options.leva && "leva",
-      options.postprocessing && "postproc",
-      options.rapier && "rapier",
-      options.xr && "xr",
-      options.uikit && "uikit",
-      options.offscreen && "offscreen",
-      options.zustand && "zustand",
-      options.koota && "koota",
-      options.triplex && "triplex",
-      options.viverse && "viverse"
-    ].filter(Boolean);
-    lines.push("");
-    lines.push(color.dim("Integrations"));
-    for (let i = 0; i < integrationNames.length; i += 2) {
-      const left = `${color.green("\u25CF")} ${integrationNames[i]}`;
-      const right = integrationNames[i + 1] ? `${color.green("\u25CF")} ${integrationNames[i + 1]}` : "";
-      const spacing = " ".repeat(Math.max(1, 16 - integrationNames[i].length));
-      lines.push(`  ${left}${spacing}${right}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatMonorepoConfigSummary(options) {
-  const lines = [];
-  const VALUE_COL = 27;
-  const formatRow = (label, value, indent = "") => {
-    const fullLabel = indent + label;
-    const dotCount = Math.max(1, VALUE_COL - fullLabel.length - 1);
-    const dots = color.gray(".".repeat(dotCount));
-    return `${indent}${label} ${dots} ${value}`;
-  };
-  lines.push(formatRow("Node version", options.nodeVersion || "latest"));
-  lines.push(formatRow("Package manager", options.packageManager || "pnpm"));
-  if (options.packageManager === "pnpm") {
-    const versionManaged = options.pnpmManageVersions ? "yes" : "no";
-    lines.push(formatRow("\u21B3 Version managed", versionManaged, ""));
-  }
-  lines.push(formatRow("Linter", options.linter));
-  lines.push(formatRow("Formatter", options.formatter));
-  return lines.join("\n");
-}
-
-const config = new Conf({
-  projectName: "create-krispya"
-});
-function getPreferredEditor() {
-  return config.get("preferredEditor");
-}
-function setPreferredEditor(editor) {
-  config.set("preferredEditor", editor);
-}
-function getReuseWindow() {
-  return config.get("reuseWindow") ?? false;
-}
-function setReuseWindow(reuse) {
-  config.set("reuseWindow", reuse);
-}
-function getAiPlatforms() {
-  return config.get("aiPlatforms");
-}
-function setAiPlatforms(platforms) {
-  config.set("aiPlatforms", platforms);
-}
-function getConfigStrategy() {
-  return config.get("configStrategy") ?? "stealth";
-}
-function clearConfig() {
-  config.clear();
-}
-function getConfigPath() {
-  return config.path;
-}
-function getCustomTemplates() {
-  return config.get("customTemplates") ?? {};
-}
-
-function getDefaultOptions(template, name, projectType = "app", libraryBundler, integrations, inheritedSettings) {
-  const baseTemplate = getBaseTemplate(template);
-  const base = {
-    name,
-    template,
-    projectType,
-    libraryBundler: projectType === "library" ? libraryBundler ?? "unbuild" : void 0,
-    packageManager: inheritedSettings?.packageManager ?? "pnpm",
-    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
-    nodeVersion: inheritedSettings?.nodeVersion ?? "latest",
-    linter: inheritedSettings?.linter ?? "oxlint",
-    formatter: inheritedSettings?.formatter ?? "prettier",
-    // Libraries get vitest by default, apps don't
-    testing: projectType === "library" ? "vitest" : "none",
-    configStrategy: getConfigStrategy()
-  };
-  if (baseTemplate === "r3f" && integrations) {
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
-}
-function getDefaultProjectName(template) {
-  const base = getBaseTemplate(template);
-  switch (base) {
-    case "vanilla":
-      return `vanilla-${generateRandomName()}`;
-    case "react":
-      return `react-${generateRandomName()}`;
-    case "r3f":
-      return `react-three-${generateRandomName()}`;
-  }
-}
-async function promptForR3fIntegrations(presets) {
-  const initialValues = [];
-  if (presets) {
-    if (presets.drei) initialValues.push("drei");
-    if (presets.handle) initialValues.push("handle");
-    if (presets.leva) initialValues.push("leva");
-    if (presets.postprocessing) initialValues.push("postprocessing");
-    if (presets.rapier) initialValues.push("rapier");
-    if (presets.xr) initialValues.push("xr");
-    if (presets.uikit) initialValues.push("uikit");
-    if (presets.offscreen) initialValues.push("offscreen");
-    if (presets.zustand) initialValues.push("zustand");
-    if (presets.koota) initialValues.push("koota");
-    if (presets.triplex) initialValues.push("triplex");
-    if (presets.viverse) initialValues.push("viverse");
-  }
-  const selected = await p.multiselect({
-    message: "R3F integrations",
-    options: [
-      { value: "drei", label: "Drei" },
-      { value: "handle", label: "Handle" },
-      { value: "leva", label: "Leva" },
-      { value: "postprocessing", label: "Postprocessing" },
-      { value: "rapier", label: "Rapier" },
-      { value: "xr", label: "XR" },
-      { value: "uikit", label: "UIKit" },
-      { value: "offscreen", label: "Offscreen" },
-      { value: "zustand", label: "Zustand" },
-      { value: "koota", label: "Koota" },
-      { value: "triplex", label: "Triplex" },
-      { value: "viverse", label: "Viverse" }
-    ],
-    initialValues: initialValues.length > 0 ? initialValues : ["drei"],
-    required: false
-  });
-  if (p.isCancel(selected)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  return selected;
-}
-async function promptForCustomization(template, name, projectType, integrations, inheritedSettings, presets) {
-  let libraryBundler;
-  if (projectType === "library") {
-    const bundler = await p.select({
-      message: "Library bundler",
-      options: [
-        { value: "unbuild", label: "unbuild", hint: "unjs, simple config" },
-        { value: "tsdown", label: "tsdown", hint: "fast, esbuild-based" }
-      ],
-      initialValue: presets?.bundler ?? "unbuild"
-    });
-    if (p.isCancel(bundler)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    libraryBundler = bundler;
-  }
-  let nodeVersion = inheritedSettings?.nodeVersion ?? presets?.nodeVersion ?? "latest";
-  let finalPackageManager = inheritedSettings?.packageManager ?? presets?.packageManager ?? "pnpm";
-  let pnpmManageVersions = inheritedSettings?.pnpmManageVersions ?? presets?.pnpmManageVersions ?? true;
-  if (!inheritedSettings?.nodeVersion) {
-    const nodeVersionInput = await p.text({
-      message: "Node.js version",
-      placeholder: presets?.nodeVersion ?? "latest",
-      defaultValue: presets?.nodeVersion ?? "latest",
-      validate: (value) => {
-        if (!value.length) return "Required";
-        if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
-          return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
-        }
-      }
-    });
-    if (p.isCancel(nodeVersionInput)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    nodeVersion = nodeVersionInput;
-  }
-  if (!inheritedSettings?.packageManager) {
-    const packageManager = await p.select({
-      message: "Package manager",
-      options: [
-        { value: "pnpm", label: "pnpm" },
-        { value: "npm", label: "npm" },
-        { value: "yarn", label: "yarn" }
-      ],
-      initialValue: presets?.packageManager ?? "pnpm"
-    });
-    if (p.isCancel(packageManager)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    finalPackageManager = packageManager;
-    if (packageManager === "pnpm") {
-      const managePnpm = await p.confirm({
-        message: "Enable manage-package-manager-versions?",
-        initialValue: presets?.pnpmManageVersions ?? true
-      });
-      if (p.isCancel(managePnpm)) {
-        p.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      pnpmManageVersions = managePnpm;
-    }
-  }
-  let linter = inheritedSettings?.linter ?? presets?.linter ?? "oxlint";
-  let formatter = inheritedSettings?.formatter ?? presets?.formatter ?? "prettier";
-  if (!inheritedSettings?.linter) {
-    const linterChoice = await p.select({
-      message: "Linter",
-      options: [
-        { value: "oxlint", label: "Oxlint", hint: "fast, from OXC" },
-        { value: "eslint", label: "ESLint", hint: "classic" },
-        { value: "biome", label: "Biome", hint: "all-in-one" }
-      ],
-      initialValue: presets?.linter ?? "oxlint"
-    });
-    if (p.isCancel(linterChoice)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    linter = linterChoice;
-  }
-  if (!inheritedSettings?.formatter) {
-    const formatterChoice = await p.select({
-      message: "Formatter",
-      options: [
-        { value: "prettier", label: "Prettier", hint: "widely adopted" },
-        { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
-        { value: "biome", label: "Biome", hint: "all-in-one" }
-      ],
-      initialValue: presets?.formatter ?? "prettier"
-    });
-    if (p.isCancel(formatterChoice)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    formatter = formatterChoice;
-  }
-  const testing = await p.select({
-    message: "Testing",
-    options: [
-      { value: "vitest", label: "Vitest", hint: "fast, Vite-native" },
-      { value: "none", label: "None" }
-    ],
-    initialValue: projectType === "library" ? "vitest" : "none"
-  });
-  if (p.isCancel(testing)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const language = await p.select({
-    message: "Language",
-    options: [
-      { value: "typescript", label: "TypeScript" },
-      { value: "javascript", label: "JavaScript" }
-    ],
-    initialValue: "typescript"
-  });
-  if (p.isCancel(language)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const configStrategyChoice = await p.select({
-    message: "Config strategy",
-    options: [
-      { value: "stealth", label: "stealth", hint: "configs in .config/" },
-      { value: "root", label: "root", hint: "configs at project root" }
-    ],
-    initialValue: getConfigStrategy()
-  });
-  if (p.isCancel(configStrategyChoice)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const baseTemplate = getBaseTemplate(template);
-  const finalTemplate = language === "javascript" ? `${baseTemplate}-js` : baseTemplate;
-  const base = {
-    name,
-    template: finalTemplate,
-    projectType,
-    libraryBundler: projectType === "library" ? libraryBundler : void 0,
-    nodeVersion,
-    packageManager: finalPackageManager,
-    pnpmManageVersions,
-    linter,
-    formatter,
-    testing,
-    configStrategy: configStrategyChoice
-  };
-  if (baseTemplate === "r3f" && integrations) {
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
-}
-async function promptForInitialPackage() {
-  const choice = await p.select({
-    message: "Add an initial package?",
-    options: [
-      { value: "app", label: "Application" },
-      { value: "library", label: "Library" },
-      { value: "skip", label: "Skip" }
-    ],
-    initialValue: "app"
-  });
-  if (p.isCancel(choice)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  return choice;
-}
-function getDefaultMonorepoOptions(name) {
-  return {
-    name,
-    projectType: "monorepo",
-    packageManager: "pnpm",
-    pnpmManageVersions: true,
-    nodeVersion: "latest",
-    linter: "oxlint",
-    formatter: "prettier"
-  };
-}
-async function promptForMonorepoCustomization(name, presets) {
-  const nodeVersion = await p.text({
-    message: "Node.js version",
-    placeholder: presets?.nodeVersion ?? "latest",
-    defaultValue: presets?.nodeVersion ?? "latest",
-    validate: (value) => {
-      if (!value.length) return "Required";
-      if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
-        return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
-      }
-    }
-  });
-  if (p.isCancel(nodeVersion)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const managePnpm = await p.confirm({
-    message: "Enable manage-package-manager-versions?",
-    initialValue: presets?.pnpmManageVersions ?? true
-  });
-  if (p.isCancel(managePnpm)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const linter = await p.select({
-    message: "Linter",
-    options: [
-      { value: "oxlint", label: "Oxlint", hint: "fast, from OXC" },
-      { value: "eslint", label: "ESLint", hint: "classic" },
-      { value: "biome", label: "Biome", hint: "all-in-one" }
-    ],
-    initialValue: presets?.linter ?? "oxlint"
-  });
-  if (p.isCancel(linter)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const formatter = await p.select({
-    message: "Formatter",
-    options: [
-      { value: "prettier", label: "Prettier", hint: "widely adopted" },
-      { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
-      { value: "biome", label: "Biome", hint: "all-in-one" }
-    ],
-    initialValue: presets?.formatter ?? "prettier"
-  });
-  if (p.isCancel(formatter)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  return {
-    name,
-    projectType: "monorepo",
-    nodeVersion,
-    packageManager: "pnpm",
-    pnpmManageVersions: managePnpm,
-    linter,
-    formatter
-  };
-}
-async function promptForMonorepo(workspaceName, presets) {
-  const defaultOptions = getDefaultMonorepoOptions(workspaceName);
-  if (presets) {
-    if (presets.linter) defaultOptions.linter = presets.linter;
-    if (presets.formatter) defaultOptions.formatter = presets.formatter;
-    if (presets.nodeVersion) defaultOptions.nodeVersion = presets.nodeVersion;
-    if (presets.pnpmManageVersions !== void 0)
-      defaultOptions.pnpmManageVersions = presets.pnpmManageVersions;
-  }
-  p.note(
-    formatMonorepoConfigSummary({
-      name: defaultOptions.name,
-      nodeVersion: defaultOptions.nodeVersion ?? "latest",
-      packageManager: defaultOptions.packageManager ?? "pnpm",
-      pnpmManageVersions: defaultOptions.pnpmManageVersions,
-      linter: defaultOptions.linter ?? "oxlint",
-      formatter: defaultOptions.formatter ?? "prettier"
-    }),
-    "Workspace Configuration"
-  );
-  const proceed = await p.select({
-    message: "Proceed with these settings?",
-    options: [
-      { value: "continue", label: "Yes, continue" },
-      { value: "customize", label: "No, customize settings" }
-    ],
-    initialValue: "continue"
-  });
-  if (p.isCancel(proceed)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (proceed === "continue") {
-    return defaultOptions;
-  }
-  return promptForMonorepoCustomization(workspaceName, presets);
-}
-async function promptForOptions(name, presets) {
-  let projectName = name;
-  if (!projectName) {
-    const nameResult = await p.text({
-      message: "What is your project named?",
-      placeholder: generateRandomName(),
-      defaultValue: generateRandomName(),
-      validate: (value) => {
-        if (!value.length) return "Project name is required";
-      }
-    });
-    if (p.isCancel(nameResult)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    projectName = nameResult;
-  }
-  const projectType = await p.select({
-    message: "Project type",
-    options: [
-      { value: "app", label: "Application" },
-      { value: "library", label: "Library" },
-      { value: "monorepo", label: "Monorepo" }
-    ],
-    initialValue: presets?.type ?? "app"
-  });
-  if (p.isCancel(projectType)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (projectType === "monorepo") {
-    return promptForMonorepo(projectName, presets);
-  }
-  return promptForPackageOptions(
-    projectName,
-    projectType,
-    void 0,
-    presets
-  );
-}
-function customTemplateToOptions(customTemplate, name, projectType, inheritedSettings) {
-  const baseTemplate = customTemplate.baseTemplate;
-  const template = baseTemplate;
-  const base = {
-    name,
-    template,
-    projectType,
-    packageManager: inheritedSettings?.packageManager ?? "pnpm",
-    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
-    nodeVersion: inheritedSettings?.nodeVersion ?? "latest",
-    linter: inheritedSettings?.linter ?? customTemplate.linter,
-    formatter: inheritedSettings?.formatter ?? customTemplate.formatter,
-    testing: customTemplate.testing,
-    configStrategy: customTemplate.configStrategy ?? getConfigStrategy()
-  };
-  if (baseTemplate === "r3f" && customTemplate.integrations) {
-    const integrations = customTemplate.integrations;
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
-}
-function presetsToInheritedSettings(presets) {
-  if (!presets) return void 0;
-  return {
-    linter: presets.linter,
-    formatter: presets.formatter,
-    packageManager: presets.packageManager,
-    nodeVersion: presets.nodeVersion,
-    pnpmManageVersions: presets.pnpmManageVersions
-  };
-}
-async function promptForPackageOptions(projectName, projectType, inheritedSettings, presets) {
-  const builtInOptions = [
-    { value: "vanilla", label: "Vanilla" },
-    { value: "react", label: "React" },
-    { value: "r3f", label: "React Three Fiber" }
-  ];
-  const customTemplates = getCustomTemplates();
-  const customOptions = Object.keys(customTemplates).map((name) => ({
-    value: `custom:${name}`,
-    label: name,
-    hint: "saved template"
-  }));
-  const allOptions = [...builtInOptions, ...customOptions];
-  const templateSelection = await p.select({
-    message: "Select a template",
-    options: allOptions,
-    initialValue: presets?.template ?? "vanilla"
-  });
-  if (p.isCancel(templateSelection)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const selection = templateSelection;
-  if (selection.startsWith("custom:")) {
-    const customName = selection.slice(7);
-    const customTemplate = customTemplates[customName];
-    const defaultOptions2 = customTemplateToOptions(
-      customTemplate,
-      projectName,
-      projectType,
-      inheritedSettings
-    );
-    const configTitle2 = inheritedSettings ? `Template: ${customName} (using workspace settings)` : `Template: ${customName}`;
-    p.note(formatConfigSummary(defaultOptions2, inheritedSettings), configTitle2);
-    const proceed2 = await p.select({
-      message: "Proceed with these settings?",
-      options: [
-        { value: "continue", label: "Yes, continue" },
-        { value: "customize", label: "No, customize settings" }
-      ],
-      initialValue: "continue"
-    });
-    if (p.isCancel(proceed2)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    if (proceed2 === "continue") {
-      return defaultOptions2;
-    }
-    return promptForCustomization(
-      customTemplate.baseTemplate,
-      projectName,
-      projectType,
-      customTemplate.integrations,
-      inheritedSettings
-    );
-  }
-  const template = selection;
-  const baseTemplate = getBaseTemplate(template);
-  let integrations;
-  if (baseTemplate === "r3f") {
-    integrations = await promptForR3fIntegrations(presets);
-  }
-  const defaultOptions = getDefaultOptions(
-    template,
-    projectName,
-    projectType,
-    presets?.bundler,
-    integrations,
-    inheritedSettings ?? presetsToInheritedSettings(presets)
-  );
-  const configTitle = inheritedSettings ? "Template Configuration (using workspace settings)" : "Template Configuration";
-  p.note(formatConfigSummary(defaultOptions, inheritedSettings), configTitle);
-  const proceed = await p.select({
-    message: "Proceed with these settings?",
-    options: [
-      { value: "continue", label: "Yes, continue" },
-      { value: "customize", label: "No, customize settings" }
-    ],
-    initialValue: "continue"
-  });
-  if (p.isCancel(proceed)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (proceed === "continue") {
-    return defaultOptions;
-  }
-  return promptForCustomization(
-    template,
-    projectName,
-    projectType,
-    integrations,
-    inheritedSettings,
-    presets
-  );
-}
-
-async function checkAnyExists(paths) {
-  for (const path of paths) {
-    try {
-      await access(path, constants.F_OK);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function validateWorkspace(monorepoRoot) {
-  const errors = [];
-  const tsConfigPath = join(monorepoRoot, ".config/typescript/package.json");
-  try {
-    await access(tsConfigPath, constants.F_OK);
-  } catch {
-    errors.push("Missing .config/typescript package");
-  }
-  const linterPaths = [
-    join(monorepoRoot, ".config/oxlint/package.json"),
-    join(monorepoRoot, ".config/eslint/package.json"),
-    join(monorepoRoot, "eslint.config.js"),
-    join(monorepoRoot, "biome.json")
-  ];
-  const hasLinter = await checkAnyExists(linterPaths);
-  if (!hasLinter) {
-    errors.push(
-      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
-    );
-  }
-  const formatterPaths = [
-    join(monorepoRoot, ".config/oxfmt/package.json"),
-    join(monorepoRoot, ".config/prettier/package.json"),
-    join(monorepoRoot, ".prettierrc.json"),
-    join(monorepoRoot, "biome.json")
-  ];
-  const hasFormatter = await checkAnyExists(formatterPaths);
-  if (!hasFormatter) {
-    errors.push(
-      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
-    );
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-async function detectCurrentConfig(root) {
-  let name = root.split(/[/\\]/).pop() ?? "workspace";
-  try {
-    const pkgPath = join(root, "package.json");
-    const content = await readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    if (pkgJson.name) {
-      name = pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
-    }
-  } catch {
-  }
-  const tooling = await detectTooling(root);
-  return {
-    name,
-    linter: tooling.linter ?? "oxlint",
-    formatter: tooling.formatter ?? "prettier",
-    packageManager: "pnpm"
-  };
-}
-function generateExpectedFiles(config) {
-  const { name, linter, formatter, packageManager } = config;
-  const aiFilesMap = {};
-  generateAiFiles(aiFilesMap, {
-    name,
-    packageManager,
-    linter,
-    formatter,
-    isMonorepo: true,
-    platforms: ALL_AI_PLATFORMS
-  });
-  const vscodeFiles = {};
-  generateVscodeFiles(vscodeFiles, linter, formatter);
-  const configPackages = {};
-  generateTypescriptConfigPackage(configPackages);
-  if (linter === "oxlint") {
-    generateOxlintConfigPackage(configPackages);
-  } else if (linter === "eslint") {
-    generateEslintConfigPackage(configPackages);
-  }
-  if (formatter === "oxfmt") {
-    generateOxfmtConfigPackage(configPackages);
-  } else if (formatter === "prettier") {
-    generatePrettierConfigPackage(configPackages);
-  }
-  const workspaceConfig = {};
-  const rootConfig = {};
-  rootConfig[".gitignore"] = {
-    type: "text",
-    content: ["node_modules", "dist", "*.tsbuildinfo", ".DS_Store"].join("\n")
-  };
-  rootConfig[".gitattributes"] = {
-    type: "text",
-    content: `* text=auto eol=lf
-*.{cmd,[cC][mM][dD]} text eol=crlf
-*.{bat,[bB][aA][tT]} text eol=crlf
-`
-  };
-  if (linter === "biome" || formatter === "biome") {
-    const biomeConfig = {
-      $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-      vcs: {
-        enabled: true,
-        clientKind: "git",
-        useIgnoreFile: true
-      },
-      linter: {
-        enabled: linter === "biome",
-        rules: {
-          recommended: true
-        }
-      },
-      formatter: {
-        enabled: formatter === "biome"
-      }
-    };
-    rootConfig["biome.json"] = {
-      type: "text",
-      content: JSON.stringify(biomeConfig, null, 2)
-    };
-  }
-  return {
-    "ai-files": aiFilesMap,
-    vscode: vscodeFiles,
-    "config-packages": configPackages,
-    "workspace-config": workspaceConfig,
-    "root-config": rootConfig
-  };
-}
-async function fileExists$1(path) {
-  try {
-    await access(path, constants$1.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function compareWithDisk(expected, root) {
-  const categoryLabels = {
-    "ai-files": "AI Files",
-    vscode: "VS Code",
-    "config-packages": "Config Packages",
-    "workspace-config": "Workspace Config",
-    "root-config": "Root Config"
-  };
-  const categories = [];
-  for (const [category, files] of Object.entries(expected)) {
-    const changes = [];
-    for (const [filePath, file] of Object.entries(files)) {
-      if (file.type !== "text") continue;
-      const fullPath = join(root, filePath);
-      const newContent = file.content;
-      if (await fileExists$1(fullPath)) {
-        const currentContent = await readFile(fullPath, "utf-8");
-        if (currentContent === newContent) {
-          changes.push({
-            path: filePath,
-            status: "unchanged",
-            currentContent,
-            newContent
-          });
-        } else {
-          changes.push({
-            path: filePath,
-            status: "modified",
-            currentContent,
-            newContent
-          });
-        }
-      } else {
-        changes.push({
-          path: filePath,
-          status: "added",
-          newContent
-        });
-      }
-    }
-    if (changes.length === 0) continue;
-    const hasUserModifications = changes.some((c) => c.status === "modified");
-    categories.push({
-      category,
-      label: categoryLabels[category],
-      changes,
-      hasUserModifications
-    });
-  }
-  return categories;
-}
-async function getWorkspaceConfigUpdates(root) {
-  const workspacePath = join(root, "pnpm-workspace.yaml");
-  const changes = [];
-  let currentContent = "";
-  let exists = false;
-  try {
-    currentContent = await readFile(workspacePath, "utf-8");
-    exists = true;
-  } catch {
-  }
-  if (!exists) {
-    const newContent = `manage-package-manager-versions: true
-
-packages:
-  - ".config/*"
-  - "apps/*"
-  - "packages/*"
-
-onlyBuiltDependencies:
-  - esbuild
-`;
-    changes.push({
-      path: "pnpm-workspace.yaml",
-      status: "added",
-      newContent
-    });
-    return changes;
-  }
-  let updatedContent = currentContent;
-  let needsUpdate = false;
-  if (!currentContent.includes("manage-package-manager-versions")) {
-    updatedContent = `manage-package-manager-versions: true
-
-${updatedContent}`;
-    needsUpdate = true;
-  }
-  if (!currentContent.includes("onlyBuiltDependencies")) {
-    updatedContent = `${updatedContent.trimEnd()}
-
-onlyBuiltDependencies:
-  - esbuild
-`;
-    needsUpdate = true;
-  }
-  if (!currentContent.includes(".config/*") && !currentContent.includes('".config/*"')) {
-    const lines = updatedContent.split("\n");
-    const packagesIndex = lines.findIndex(
-      (line) => line.trim().startsWith("packages:")
-    );
-    if (packagesIndex !== -1) {
-      lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
-      updatedContent = lines.join("\n");
-      needsUpdate = true;
-    }
-  }
-  if (needsUpdate) {
-    changes.push({
-      path: "pnpm-workspace.yaml",
-      status: "modified",
-      currentContent,
-      newContent: updatedContent
-    });
-  } else {
-    changes.push({
-      path: "pnpm-workspace.yaml",
-      status: "unchanged",
-      currentContent,
-      newContent: currentContent
-    });
-  }
-  return changes;
-}
-async function applyUpdates(changes, root) {
-  for (const change of changes) {
-    if (change.status === "unchanged") continue;
-    const fullPath = join(root, change.path);
-    await mkdir(dirname(fullPath), { recursive: true });
-    await writeFile(fullPath, change.newContent);
-  }
-}
-function formatFileChange(change) {
-  const icon = change.status === "added" ? "+" : change.status === "modified" ? "~" : "=";
-  return `  ${icon} ${change.path}`;
-}
-const LINTER_DEPS = {
-  oxlint: "oxlint",
-  eslint: "eslint",
-  biome: "@biomejs/biome"
-};
-const FORMATTER_DEPS = {
-  oxfmt: "oxfmt",
-  prettier: "prettier",
-  biome: "@biomejs/biome"
-};
-const LINTER_CONFIG_PACKAGES = {
-  oxlint: "@config/oxlint",
-  eslint: "@config/eslint",
-  biome: null
-  // biome uses root biome.json
-};
-const FORMATTER_CONFIG_PACKAGES = {
-  oxfmt: "@config/oxfmt",
-  prettier: "@config/prettier",
-  biome: null
-  // biome uses root biome.json
-};
-function needsMigration(current, target) {
-  const linterChange = target.linter && target.linter !== current.linter;
-  const formatterChange = target.formatter && target.formatter !== current.formatter;
-  return linterChange || formatterChange || false;
-}
-async function getMigrationPlan(current, target, root) {
-  const toLinter = target.linter ?? current.linter;
-  const toFormatter = target.formatter ?? current.formatter;
-  const changes = [];
-  if (toLinter !== current.linter) {
-    if (current.linter !== "biome") {
-      changes.push({
-        type: "remove-dir",
-        path: `.config/${current.linter}`,
-        description: `Remove @config/${current.linter} package`
-      });
-    }
-    if (toLinter !== "biome") {
-      const files = {};
-      if (toLinter === "oxlint") {
-        generateOxlintConfigPackage(files);
-      } else if (toLinter === "eslint") {
-        generateEslintConfigPackage(files);
-      }
-      for (const [path, file] of Object.entries(files)) {
-        if (file.type === "text") {
-          changes.push({
-            type: "add-file",
-            path,
-            description: `Add ${path}`,
-            content: file.content
-          });
-        }
-      }
-    }
-    if (toLinter === "biome" && toFormatter === "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config",
-        content: JSON.stringify(
-          {
-            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: true, rules: { recommended: true } },
-            formatter: { enabled: true }
-          },
-          null,
-          2
-        )
-      });
-    } else if (toLinter === "biome" && toFormatter !== "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config (linter only)",
-        content: JSON.stringify(
-          {
-            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: true, rules: { recommended: true } },
-            formatter: { enabled: false }
-          },
-          null,
-          2
-        )
-      });
-    }
-    if (current.linter === "biome" && toLinter !== "biome" && current.formatter !== "biome" && toFormatter !== "biome") {
-      changes.push({
-        type: "remove-file",
-        path: "biome.json",
-        description: "Remove biome.json"
-      });
-    }
-  }
-  if (toFormatter !== current.formatter) {
-    const formatterSameAsLinter = current.formatter === current.linter;
-    if (current.formatter !== "biome" && !formatterSameAsLinter) {
-      changes.push({
-        type: "remove-dir",
-        path: `.config/${current.formatter}`,
-        description: `Remove @config/${current.formatter} package`
-      });
-    }
-    const newFormatterSameAsLinter = toFormatter === toLinter;
-    if (toFormatter !== "biome" && !newFormatterSameAsLinter) {
-      const files = {};
-      if (toFormatter === "oxfmt") {
-        generateOxfmtConfigPackage(files);
-      } else if (toFormatter === "prettier") {
-        generatePrettierConfigPackage(files);
-      }
-      for (const [path, file] of Object.entries(files)) {
-        if (file.type === "text") {
-          changes.push({
-            type: "add-file",
-            path,
-            description: `Add ${path}`,
-            content: file.content
-          });
-        }
-      }
-    }
-    if (toFormatter === "biome" && toLinter !== "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config (formatter only)",
-        content: JSON.stringify(
-          {
-            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: false },
-            formatter: { enabled: true }
-          },
-          null,
-          2
-        )
-      });
-    }
-    if (current.formatter === "biome" && toFormatter !== "biome" && current.linter !== "biome" && toLinter !== "biome") {
-      changes.push({
-        type: "remove-file",
-        path: "biome.json",
-        description: "Remove biome.json"
-      });
-    }
-  }
-  changes.push({
-    type: "update-package-json",
-    path: "package.json",
-    description: "Update root package.json (devDependencies, scripts)"
-  });
-  const subPackageUpdates = await getSubPackageUpdates(
-    root,
-    current,
-    toLinter,
-    toFormatter
-  );
-  return {
-    fromLinter: current.linter,
-    toLinter,
-    fromFormatter: current.formatter,
-    toFormatter,
-    changes,
-    subPackageUpdates
-  };
-}
-async function getSubPackageUpdates(root, current, toLinter, toFormatter) {
-  const updates = [];
-  const workspacePath = join(root, "pnpm-workspace.yaml");
-  let workspaceContent;
-  try {
-    workspaceContent = await readFile(workspacePath, "utf-8");
-  } catch {
-    return updates;
-  }
-  const packageGlobs = parseWorkspaceYamlContent(workspaceContent);
-  for (const glob of packageGlobs) {
-    if (glob.includes(".config")) continue;
-    const baseDir = glob.replace(/\/\*$/, "").replace(/^["']|["']$/g, "");
-    const basePath = join(root, baseDir);
-    try {
-      const entries = await readdir(basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const pkgJsonPath = join(basePath, entry.name, "package.json");
-        try {
-          const content = await readFile(pkgJsonPath, "utf-8");
-          const pkg = JSON.parse(content);
-          const devDeps = pkg.devDependencies ?? {};
-          const remove = [];
-          const add = [];
-          const oldLinterPkg = LINTER_CONFIG_PACKAGES[current.linter];
-          const newLinterPkg = LINTER_CONFIG_PACKAGES[toLinter];
-          if (oldLinterPkg && oldLinterPkg !== newLinterPkg && devDeps[oldLinterPkg]) {
-            remove.push(oldLinterPkg);
-          }
-          if (newLinterPkg && newLinterPkg !== oldLinterPkg && oldLinterPkg && devDeps[oldLinterPkg]) {
-            add.push(newLinterPkg);
-          }
-          if (current.formatter !== current.linter) {
-            const oldFormatterPkg = FORMATTER_CONFIG_PACKAGES[current.formatter];
-            const newFormatterPkg = FORMATTER_CONFIG_PACKAGES[toFormatter];
-            if (oldFormatterPkg && oldFormatterPkg !== newFormatterPkg && devDeps[oldFormatterPkg]) {
-              remove.push(oldFormatterPkg);
-            }
-            if (newFormatterPkg && newFormatterPkg !== oldFormatterPkg && oldFormatterPkg && devDeps[oldFormatterPkg]) {
-              add.push(newFormatterPkg);
-            }
-          }
-          if (remove.length > 0 || add.length > 0) {
-            updates.push({
-              path: join(baseDir, entry.name, "package.json"),
-              remove,
-              add
-            });
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return updates;
-}
-async function applyMigration(plan, root) {
-  for (const change of plan.changes) {
-    if (change.type === "remove-dir") {
-      const fullPath = join(root, change.path);
-      try {
-        await rm(fullPath, { recursive: true });
-      } catch {
-      }
-    }
-  }
-  for (const change of plan.changes) {
-    if (change.type === "remove-file") {
-      const fullPath = join(root, change.path);
-      try {
-        await rm(fullPath);
-      } catch {
-      }
-    }
-  }
-  for (const change of plan.changes) {
-    if (change.type === "add-file" && change.content) {
-      const fullPath = join(root, change.path);
-      await mkdir(dirname(fullPath), { recursive: true });
-      await writeFile(fullPath, change.content);
-    }
-  }
-  await updateRootPackageJson(root, plan);
-  for (const update of plan.subPackageUpdates) {
-    await updateSubPackageJson(root, update);
-  }
-}
-async function updateRootPackageJson(root, plan) {
-  const pkgPath = join(root, "package.json");
-  const content = await readFile(pkgPath, "utf-8");
-  const pkg = JSON.parse(content);
-  const devDeps = pkg.devDependencies ?? {};
-  const oldLinterDep = LINTER_DEPS[plan.fromLinter];
-  delete devDeps[oldLinterDep];
-  if (plan.fromFormatter !== plan.fromLinter) {
-    const oldFormatterDep = FORMATTER_DEPS[plan.fromFormatter];
-    delete devDeps[oldFormatterDep];
-  }
-  const newLinterDep = LINTER_DEPS[plan.toLinter];
-  if (plan.toLinter === "oxlint") {
-    devDeps[newLinterDep] = "^1.36.0";
-  } else if (plan.toLinter === "eslint") {
-    devDeps[newLinterDep] = "^9.17.0";
-  } else if (plan.toLinter === "biome") {
-    devDeps[newLinterDep] = "^1.9.4";
-  }
-  if (plan.toFormatter !== plan.toLinter) {
-    const newFormatterDep = FORMATTER_DEPS[plan.toFormatter];
-    if (plan.toFormatter === "oxfmt") {
-      devDeps[newFormatterDep] = "^0.21.0";
-    } else if (plan.toFormatter === "prettier") {
-      devDeps[newFormatterDep] = "^3.4.2";
-    } else if (plan.toFormatter === "biome") {
-      devDeps[newFormatterDep] = "^1.9.4";
-    }
-  }
-  pkg.devDependencies = Object.fromEntries(
-    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
-  );
-  const scripts = pkg.scripts ?? {};
-  if (plan.toLinter === "oxlint") {
-    scripts.lint = "oxlint .";
-  } else if (plan.toLinter === "eslint") {
-    scripts.lint = "eslint .";
-  } else if (plan.toLinter === "biome") {
-    scripts.lint = "biome check .";
-  }
-  if (plan.toFormatter === "oxfmt") {
-    scripts.format = "oxfmt .";
-  } else if (plan.toFormatter === "prettier") {
-    scripts.format = "prettier --write .";
-  } else if (plan.toFormatter === "biome") {
-    scripts.format = "biome format . --write";
-  }
-  pkg.scripts = scripts;
-  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-}
-async function updateSubPackageJson(root, update) {
-  const pkgPath = join(root, update.path);
-  const content = await readFile(pkgPath, "utf-8");
-  const pkg = JSON.parse(content);
-  const devDeps = pkg.devDependencies ?? {};
-  for (const dep of update.remove) {
-    delete devDeps[dep];
-  }
-  for (const dep of update.add) {
-    devDeps[dep] = "workspace:*";
-  }
-  pkg.devDependencies = Object.fromEntries(
-    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
-  );
-  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-}
-function formatMigrationChange(change) {
-  const icon = change.type === "remove-dir" || change.type === "remove-file" ? "-" : change.type === "add-file" ? "+" : "~";
-  return `  ${icon} ${change.description}`;
-}
-
-const require$1 = createRequire(import.meta.url);
-const pkg = require$1("../package.json");
-const META_OPTIONS = [
-  "clearConfig",
-  "configPath",
-  "check",
-  "fix",
-  "update",
-  "yes",
-  "workspace",
-  "path",
-  "dir"
-];
-function hasConfigOptions(options) {
-  return Object.keys(options).some(
-    (key) => !META_OPTIONS.includes(key)
-  );
-}
-async function fileExists(path) {
-  try {
-    await access(path, constants$1.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function promptForAiPlatforms(isNonInteractive) {
-  const savedPlatforms = getAiPlatforms();
-  if (isNonInteractive) {
-    return savedPlatforms ?? ALL_AI_PLATFORMS;
-  }
-  if (savedPlatforms && savedPlatforms.length > 0) {
-    const savedLabels = savedPlatforms.map((plat) => AI_PLATFORM_LABELS[plat]).join(", ");
-    const useDefault = await p.confirm({
-      message: `Add AI rules? ${color.dim(`(${savedLabels})`)}`,
-      initialValue: true
-    });
-    if (p.isCancel(useDefault)) {
-      return [];
-    }
-    if (useDefault) {
-      return savedPlatforms;
-    }
-  }
-  const selected = await p.multiselect({
-    message: "Add AI rules?",
-    options: ALL_AI_PLATFORMS.map((platform) => ({
-      value: platform,
-      label: AI_PLATFORM_LABELS[platform],
-      hint: AI_PLATFORM_HINTS[platform]
-    })),
-    initialValues: [],
-    required: false
-  });
-  if (p.isCancel(selected)) {
-    return [];
-  }
-  const platforms = selected;
-  if (platforms.length === 0) {
-    return [];
-  }
-  const saveChoice = await p.confirm({
-    message: "Save selection for future projects?",
-    initialValue: true
-  });
-  if (!p.isCancel(saveChoice) && saveChoice) {
-    setAiPlatforms(platforms);
-  }
-  return platforms;
-}
-async function writeGeneratedFiles(basePath, files) {
-  const filePaths = Object.keys(files).sort();
-  for (const filePath of filePaths) {
-    const fullFilePath = join(basePath, filePath);
-    await mkdir(dirname(fullFilePath), { recursive: true });
-    const file = files[filePath];
-    if (file.type === "text") {
-      await writeFile(fullFilePath, file.content);
-    } else {
-      const response = await fetch(file.url);
-      await writeFile(fullFilePath, response.body);
-    }
-  }
-}
-function calculateWorkspaceRoot(packagePath) {
-  const segments = packagePath.split(/[/\\]/).filter(Boolean);
-  return segments.map(() => "..").join("/");
-}
-async function detectMonorepoRoot() {
-  let currentDir = cwd();
-  const root = resolve("/");
-  while (currentDir !== root) {
-    const workspaceFile = join(currentDir, "pnpm-workspace.yaml");
-    try {
-      await access(workspaceFile, constants$1.F_OK);
-      const content = await readFile(workspaceFile, "utf-8");
-      if (content.includes("packages:")) {
-        return currentDir;
-      }
-    } catch {
-    }
-    currentDir = dirname(currentDir);
-  }
-  return null;
-}
-async function parseWorkspaceDirectories(monorepoRoot) {
-  try {
-    const workspaceFile = join(monorepoRoot, "pnpm-workspace.yaml");
-    const content = await readFile(workspaceFile, "utf-8");
-    return parseWorkspaceYamlContent(content);
-  } catch {
-    return [];
-  }
-}
-async function detectWorkspaceSettings(monorepoRoot) {
-  try {
-    const tooling = await detectTooling(monorepoRoot);
-    const pkgPath = join(monorepoRoot, "package.json");
-    const content = await readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    let packageManager;
-    if (pkgJson.packageManager) {
-      packageManager = pkgJson.packageManager.split("@")[0];
-    }
-    let nodeVersion;
-    if (pkgJson.engines?.node) {
-      const match = pkgJson.engines.node.match(/(\d+)/);
-      if (match) {
-        nodeVersion = match[1];
-      }
-    }
-    let pnpmManageVersions;
-    try {
-      const workspaceFile = join(monorepoRoot, "pnpm-workspace.yaml");
-      const workspaceContent = await readFile(workspaceFile, "utf-8");
-      pnpmManageVersions = workspaceContent.includes(
-        "manage-package-manager-versions: true"
-      );
-    } catch {
-    }
-    return {
-      linter: tooling.linter,
-      formatter: tooling.formatter,
-      packageManager,
-      nodeVersion,
-      pnpmManageVersions
-    };
-  } catch {
-    return {};
-  }
-}
-async function detectExistingConfigs(monorepoRoot) {
-  const configs = {};
-  const eslintPath = join(monorepoRoot, "eslint.config.js");
-  if (await fileExists(eslintPath)) {
-    configs.linter = "eslint";
-    configs.eslintConfigPath = eslintPath;
-  }
-  const prettierPath = join(monorepoRoot, ".prettierrc.json");
-  if (await fileExists(prettierPath)) {
-    configs.formatter = "prettier";
-    configs.prettierConfigPath = prettierPath;
-  }
-  const biomePath = join(monorepoRoot, "biome.json");
-  if (await fileExists(biomePath)) {
-    configs.biomeConfigPath = biomePath;
-    if (!configs.linter) configs.linter = "biome";
-    if (!configs.formatter) configs.formatter = "biome";
-  }
-  return configs;
-}
-async function getMonorepoScope(monorepoRoot) {
-  try {
-    const pkgPath = join(monorepoRoot, "package.json");
-    const content = await readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    if (pkgJson.name) {
-      return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
-    }
-  } catch {
-  }
-  return monorepoRoot.split(/[/\\]/).pop() ?? "workspace";
-}
-async function getWorkspacePackages(monorepoRoot) {
-  const packagesDir = join(monorepoRoot, "packages");
-  try {
-    const { readdir } = await import('fs/promises');
-    const entries = await readdir(packagesDir, { withFileTypes: true });
-    const names = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      try {
-        const content = await readFile(
-          join(packagesDir, entry.name, "package.json"),
-          "utf-8"
-        );
-        const pkg2 = JSON.parse(content);
-        if (pkg2.name) names.push(pkg2.name);
-      } catch {
-      }
-    }
-    return names;
-  } catch {
-    return [];
-  }
-}
-async function ensureConfigInWorkspace(monorepoRoot) {
-  const workspacePath = join(monorepoRoot, "pnpm-workspace.yaml");
-  let content;
-  try {
-    content = await readFile(workspacePath, "utf-8");
-  } catch {
-    content = `packages:
-  - ".config/*"
-  - "packages/*"
-`;
-    await writeFile(workspacePath, content);
-    return;
-  }
-  if (content.includes(".config/*") || content.includes('".config/*"')) {
-    return;
-  }
-  const lines = content.split("\n");
-  const packagesIndex = lines.findIndex(
-    (line) => line.trim().startsWith("packages:")
-  );
-  if (packagesIndex === -1) {
-    content = `packages:
-  - ".config/*"
-${content}`;
-  } else {
-    lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
-    content = lines.join("\n");
-  }
-  await writeFile(workspacePath, content);
-}
-async function migrateEslintConfig(monorepoRoot, files) {
-  const configBasePath = ".config/eslint";
-  const existingConfigPath = join(monorepoRoot, "eslint.config.js");
-  let existingContent;
-  try {
-    existingContent = await readFile(existingConfigPath, "utf-8");
-  } catch {
-    generateEslintConfigPackage(files);
-    return;
-  }
-  files[`${configBasePath}/package.json`] = {
-    type: "text",
-    content: JSON.stringify(
-      {
-        name: "@config/eslint",
-        version: "0.1.0",
-        private: true,
-        type: "module",
-        exports: {
-          "./base": "./base.js",
-          "./react": "./react.js"
-        }
-      },
-      null,
-      2
-    )
-  };
-  files[`${configBasePath}/README.md`] = {
-    type: "text",
-    content: `# \`@config/eslint\`
-
-Shared ESLint configurations.
-
-## Usage
-
-In your package's \`eslint.config.js\`:
-
-\`\`\`js
-import base from "@config/eslint/base";
-
-export default [...base];
-\`\`\`
-
-## Available Configs
-
-- \`base\` - Base ESLint rules (migrated from root)
-- \`react\` - React-specific rules
-`
-  };
-  files[`${configBasePath}/base.js`] = {
-    type: "text",
-    content: existingContent
-  };
-  files[`${configBasePath}/react.js`] = {
-    type: "text",
-    content: `import react from "eslint-plugin-react";
-import reactHooks from "eslint-plugin-react-hooks";
-
-export default [
-  {
-    plugins: {
-      react,
-      "react-hooks": reactHooks,
-    },
-    rules: {
-      ...react.configs.recommended.rules,
-      ...reactHooks.configs.recommended.rules,
-      "react/react-in-jsx-scope": "off",
-    },
-    settings: {
-      react: {
-        version: "detect",
-      },
-    },
-  },
-];
-`
-  };
-}
-async function migratePrettierConfig(monorepoRoot, files) {
-  const configBasePath = ".config/prettier";
-  const existingConfigPath = join(monorepoRoot, ".prettierrc.json");
-  let existingContent;
-  try {
-    existingContent = await readFile(existingConfigPath, "utf-8");
-  } catch {
-    generatePrettierConfigPackage(files);
-    return;
-  }
-  files[`${configBasePath}/package.json`] = {
-    type: "text",
-    content: JSON.stringify(
-      {
-        name: "@config/prettier",
-        version: "0.1.0",
-        private: true,
-        exports: {
-          "./base": "./base.json"
-        }
-      },
-      null,
-      2
-    )
-  };
-  files[`${configBasePath}/README.md`] = {
-    type: "text",
-    content: `# \`@config/prettier\`
-
-Shared Prettier configurations.
-
-## Usage
-
-In your package's \`.prettierrc\`:
-
-\`\`\`json
-"@config/prettier/base"
-\`\`\`
-
-Or in \`package.json\`:
-
-\`\`\`json
-{
-  "prettier": "@config/prettier/base"
-}
-\`\`\`
-
-## Available Configs
-
-- \`base\` - Base Prettier rules (migrated from root)
-`
-  };
-  files[`${configBasePath}/base.json`] = {
-    type: "text",
-    content: existingContent
-  };
-}
-async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedSettings, scope) {
-  const workspaceDirectories = await parseWorkspaceDirectories(monorepoRoot);
-  const defaultDirectories = ["apps", "packages"];
-  const hasCustomDirectories = workspaceDirectories.length > 0 && !workspaceDirectories.every((dir) => defaultDirectories.includes(dir));
-  const packageType = await promptForInitialPackage();
-  if (packageType === "skip") {
-    return false;
-  }
-  const defaultDir = packageType === "app" ? "apps" : "packages";
-  const packageNameInput = await p.text({
-    message: "Package name?",
-    initialValue: `@${scope}/`,
-    validate: (value) => {
-      const validationError = validatePackageName(value);
-      if (validationError) return validationError;
-      const dirName = value.includes("/") ? value.split("/").pop() : value;
-      if (!dirName) return "Package name is required";
-      if (!hasCustomDirectories) {
-        const targetPath = join(monorepoRoot, defaultDir, dirName);
-        try {
-          const { statSync } = require$1("fs");
-          statSync(targetPath);
-          return `Directory ${defaultDir}/${dirName} already exists`;
-        } catch {
-        }
-      }
-    }
-  });
-  if (p.isCancel(packageNameInput)) {
-    return false;
-  }
-  const scopedName = packageNameInput;
-  const shortName = scopedName.includes("/") ? scopedName.split("/").pop() : scopedName;
-  const packageOptions = await promptForPackageOptions(
-    scopedName,
-    packageType,
-    inheritedSettings
-  );
-  let targetDir = defaultDir;
-  if (hasCustomDirectories && workspaceDirectories.length > 0) {
-    const dirChoice = await p.select({
-      message: "Target directory",
-      options: workspaceDirectories.map((dir) => ({
-        value: dir,
-        label: dir
-      })),
-      initialValue: workspaceDirectories.includes(defaultDir) ? defaultDir : workspaceDirectories[0]
-    });
-    if (p.isCancel(dirChoice)) {
-      return false;
-    }
-    targetDir = dirChoice;
-    const targetPath = join(monorepoRoot, targetDir, shortName);
-    try {
-      const { statSync } = require$1("fs");
-      statSync(targetPath);
-      p.log.error(`Directory ${targetDir}/${shortName} already exists`);
-      return false;
-    } catch {
-    }
-  }
-  const relativePkgPath = join(targetDir, shortName);
-  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
-  packageOptions.workspaceRoot = workspaceRoot;
-  packageOptions.name = scopedName;
-  if (packageManager === "pnpm") {
-    packageOptions.pnpmVersion = await getLatestPnpmVersion();
-  } else if (packageManager === "yarn") {
-    packageOptions.yarnVersion = await getLatestYarnVersion();
-  } else if (packageManager === "npm") {
-    packageOptions.npmVersion = await getLatestNpmCliVersion();
-  }
-  const nodeVersion = packageOptions.nodeVersion ?? "latest";
-  if (nodeVersion === "latest") {
-    packageOptions.nodeVersion = await getLatestNodeVersion();
-  }
-  const versions = {};
-  const versionPromises = [];
-  const pkgIsLibrary = packageOptions.projectType === "library";
-  const pkgTesting = packageOptions.testing ?? (pkgIsLibrary ? "vitest" : "none");
-  if (pkgTesting === "vitest") {
-    versionPromises.push(
-      getLatestNpmVersion("vitest", "4.0.0").then((v) => {
-        versions.vitest = v;
-      })
-    );
-  }
-  if (!pkgIsLibrary) {
-    versionPromises.push(
-      getLatestNpmVersion("vite", "6.3.4").then((v) => {
-        versions.vite = v;
-      })
-    );
-  }
-  const linter = packageOptions.linter ?? "oxlint";
-  if (linter === "eslint") {
-    versionPromises.push(
-      getLatestNpmVersion("eslint", "9.17.0").then((v) => {
-        versions.eslint = v;
-      })
-    );
-  } else if (linter === "oxlint") {
-    versionPromises.push(
-      getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
-        versions.oxlint = v;
-      })
-    );
-  } else if (linter === "biome") {
-    versionPromises.push(
-      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-        versions.biome = v;
-      })
-    );
-  }
-  const formatter = packageOptions.formatter ?? "prettier";
-  if (formatter === "prettier") {
-    versionPromises.push(
-      getLatestNpmVersion("prettier", "3.4.2").then((v) => {
-        versions.prettier = v;
-      })
-    );
-  } else if (formatter === "oxfmt") {
-    versionPromises.push(
-      getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
-        versions.oxfmt = v;
-      })
-    );
-  } else if (formatter === "biome" && linter !== "biome") {
-    versionPromises.push(
-      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-        versions.biome = v;
-      })
-    );
-  }
-  await Promise.all(versionPromises);
-  packageOptions.versions = versions;
-  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
-  if (workspacePackages.length > 0) {
-    const selectedDeps = await p.multiselect({
-      message: "Add workspace dependencies?",
-      options: workspacePackages.map((name) => ({ value: name, label: name })),
-      required: false
-    });
-    if (!p.isCancel(selectedDeps) && selectedDeps.length > 0) {
-      packageOptions.workspaceDependencies = selectedDeps;
-    }
-  }
-  const outputPath = join(monorepoRoot, relativePkgPath);
-  const spinner = p.spinner();
-  spinner.start("Creating package...");
-  try {
-    const files = generate(packageOptions);
-    await writeGeneratedFiles(outputPath, files);
-    spinner.stop(
-      color.green.inverse(` \u2713 Package created at ${relativePkgPath}! `)
-    );
-    const addAnother = await p.select({
-      message: "Add another package?",
-      options: [
-        { value: "no", label: "No, I'm done" },
-        { value: "yes", label: "Yes, add another" }
-      ],
-      initialValue: "no"
-    });
-    return !p.isCancel(addAnother) && addAnother === "yes";
-  } catch (error) {
-    spinner.stop("Failed to create package");
-    p.log.error(String(error));
-    return false;
-  }
-}
-async function promptAndOpenEditor(projectPath) {
-  const savedEditor = getPreferredEditor();
-  let selectedEditor;
-  if (savedEditor && savedEditor !== "skip") {
-    const useDefault = await p.confirm({
-      message: `Open in editor? ${color.dim(`(${editorNames[savedEditor]})`)}`,
-      initialValue: true
-    });
-    if (p.isCancel(useDefault)) {
-      selectedEditor = void 0;
-    } else if (useDefault) {
-      selectedEditor = savedEditor;
-    } else {
-      selectedEditor = "skip";
-    }
-  } else {
-    const openEditor = await p.select({
-      message: "Open project in editor?",
-      options: [
-        { value: "skip", label: "Skip" },
-        { value: "cursor", label: "Cursor" },
-        { value: "code", label: "VS Code" },
-        { value: "webstorm", label: "WebStorm" }
-      ],
-      initialValue: "skip"
-    });
-    if (!p.isCancel(openEditor)) {
-      selectedEditor = openEditor;
-      const saveChoice = await p.confirm({
-        message: `Save ${editorNames[selectedEditor] ?? "Skip"} as default editor?`,
-        initialValue: true
-      });
-      if (!p.isCancel(saveChoice) && saveChoice) {
-        setPreferredEditor(selectedEditor);
-        if (selectedEditor === "cursor" || selectedEditor === "code") {
-          const reuseChoice = await p.confirm({
-            message: "Reuse current window when opening projects?",
-            initialValue: false
-          });
-          if (!p.isCancel(reuseChoice)) {
-            setReuseWindow(reuseChoice);
-          }
-        }
-      }
-    }
-  }
-  if (selectedEditor && selectedEditor !== "skip") {
-    try {
-      await openInEditor(
-        selectedEditor,
-        projectPath,
-        getReuseWindow()
-      );
-      p.log.success(`Opening in ${editorNames[selectedEditor]}...`);
-    } catch {
-      p.log.warn(
-        `Could not open ${editorNames[selectedEditor]}. Make sure the CLI command is in your PATH.`
-      );
-    }
-  }
-}
-async function handleCheckCommand() {
-  const monorepoRoot = await detectMonorepoRoot();
-  if (!monorepoRoot) {
-    console.log(color.red("\u2717") + " Not a monorepo workspace");
-    process.exit(1);
-  }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
-  if (valid) {
-    console.log(color.green("\u2713") + " Valid monorepo workspace");
-    console.log(color.dim(`  ${monorepoRoot}`));
-  } else {
-    console.log(color.red("\u2717") + " Invalid monorepo workspace");
-    console.log(color.dim(`  ${monorepoRoot}`));
-    for (const error of errors) {
-      console.log(color.red(`  \u2022 ${error}`));
-    }
-  }
-  process.exit(valid ? 0 : 1);
-}
-async function handleFixCommand(options) {
-  const monorepoRoot = await detectMonorepoRoot();
-  if (!monorepoRoot) {
-    console.log(color.red("\u2717") + " Not a monorepo workspace");
-    console.log(color.dim("  Run this command from within a monorepo"));
-    process.exit(1);
-  }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
-  if (valid) {
-    console.log(color.green("\u2713") + " Workspace is already valid");
-    console.log(color.dim(`  ${monorepoRoot}`));
-    process.exit(0);
-  }
-  console.log(color.yellow("!") + " Invalid monorepo workspace");
-  for (const error of errors) {
-    console.log(color.dim(`  \u2022 ${error}`));
-  }
-  console.log();
-  const tooling = await detectWorkspaceSettings(monorepoRoot);
-  const existingConfigs = await detectExistingConfigs(monorepoRoot);
-  const detectedLinter = tooling.linter ?? existingConfigs.linter ?? "oxlint";
-  const detectedFormatter = tooling.formatter ?? existingConfigs.formatter ?? "prettier";
-  const isNonInteractive = Boolean(options.linter && options.formatter);
-  let linter;
-  let formatter;
-  if (isNonInteractive) {
-    linter = options.linter;
-    formatter = options.formatter;
-  } else {
-    const linterChoice = await p.select({
-      message: "Linter",
-      options: [
-        {
-          value: "oxlint",
-          label: "oxlint" + (tooling.linter === "oxlint" ? color.dim(" (installed)") : "")
-        },
-        {
-          value: "eslint",
-          label: "eslint" + (tooling.linter === "eslint" || existingConfigs.linter === "eslint" ? color.dim(" (installed)") : "")
-        },
-        {
-          value: "biome",
-          label: "biome" + (tooling.linter === "biome" ? color.dim(" (installed)") : "")
-        }
-      ],
-      initialValue: detectedLinter
-    });
-    if (p.isCancel(linterChoice)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const formatterChoice = await p.select({
-      message: "Formatter",
-      options: [
-        {
-          value: "oxfmt",
-          label: "oxfmt" + (tooling.formatter === "oxfmt" ? color.dim(" (installed)") : "")
-        },
-        {
-          value: "prettier",
-          label: "prettier" + (tooling.formatter === "prettier" || existingConfigs.formatter === "prettier" ? color.dim(" (installed)") : "")
-        },
-        {
-          value: "biome",
-          label: "biome" + (tooling.formatter === "biome" ? color.dim(" (installed)") : "")
-        }
-      ],
-      initialValue: detectedFormatter
-    });
-    if (p.isCancel(formatterChoice)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    linter = linterChoice;
-    formatter = formatterChoice;
-  }
-  console.log();
-  const spinner = p.spinner();
-  spinner.start("Fixing workspace...");
-  try {
-    const files = {};
-    const tsConfigExists = await fileExists(
-      join(monorepoRoot, ".config/typescript/package.json")
-    );
-    if (!tsConfigExists) {
-      generateTypescriptConfigPackage(files);
-    }
-    if (linter === "oxlint") {
-      const oxlintExists = await fileExists(
-        join(monorepoRoot, ".config/oxlint/package.json")
-      );
-      if (!oxlintExists) generateOxlintConfigPackage(files);
-    } else if (linter === "eslint") {
-      const eslintPkgExists = await fileExists(
-        join(monorepoRoot, ".config/eslint/package.json")
-      );
-      if (!eslintPkgExists) {
-        if (existingConfigs.eslintConfigPath) {
-          await migrateEslintConfig(monorepoRoot, files);
-        } else {
-          generateEslintConfigPackage(files);
-        }
-      }
-    }
-    if (formatter === "oxfmt") {
-      const oxfmtExists = await fileExists(
-        join(monorepoRoot, ".config/oxfmt/package.json")
-      );
-      if (!oxfmtExists) generateOxfmtConfigPackage(files);
-    } else if (formatter === "prettier") {
-      const prettierPkgExists = await fileExists(
-        join(monorepoRoot, ".config/prettier/package.json")
-      );
-      if (!prettierPkgExists) {
-        if (existingConfigs.prettierConfigPath) {
-          await migratePrettierConfig(monorepoRoot, files);
-        } else {
-          generatePrettierConfigPackage(files);
-        }
-      }
-    }
-    if ((linter === "biome" || formatter === "biome") && !existingConfigs.biomeConfigPath) {
-      const biomeConfig = {
-        $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
-        vcs: {
-          enabled: true,
-          clientKind: "git",
-          useIgnoreFile: true
-        },
-        linter: {
-          enabled: linter === "biome",
-          rules: {
-            recommended: true
-          }
-        },
-        formatter: {
-          enabled: formatter === "biome"
-        }
-      };
-      files["biome.json"] = {
-        type: "text",
-        content: JSON.stringify(biomeConfig, null, 2)
-      };
-    }
-    for (const [filePath, file] of Object.entries(files)) {
-      const fullPath = join(monorepoRoot, filePath);
-      await mkdir(dirname(fullPath), { recursive: true });
-      await writeFile(fullPath, file.content);
-    }
-    await ensureConfigInWorkspace(monorepoRoot);
-    if (existingConfigs.eslintConfigPath && linter === "eslint") {
-      try {
-        await unlink(existingConfigs.eslintConfigPath);
-      } catch {
-      }
-    }
-    if (existingConfigs.prettierConfigPath && formatter === "prettier") {
-      try {
-        await unlink(existingConfigs.prettierConfigPath);
-      } catch {
-      }
-    }
-    spinner.stop(color.green("\u2713") + " Workspace fixed!");
-    const generated = Object.keys(files).filter(
-      (f) => f.endsWith("package.json")
-    );
-    for (const pkgFile of generated) {
-      const pkgName = pkgFile.replace("/package.json", "");
-      console.log(color.dim(`  Generated ${pkgName}`));
-    }
-    const vscodeSettingsExists = await fileExists(
-      join(monorepoRoot, ".vscode/settings.json")
-    );
-    const vscodeExtensionsExists = await fileExists(
-      join(monorepoRoot, ".vscode/extensions.json")
-    );
-    const vscodeExists = vscodeSettingsExists && vscodeExtensionsExists;
-    if (!vscodeExists) {
-      let addVscode = false;
-      if (isNonInteractive) {
-        addVscode = true;
-      } else {
-        const vscodeChoice = await p.confirm({
-          message: "Generate VS Code settings?",
-          initialValue: true
-        });
-        addVscode = !p.isCancel(vscodeChoice) && vscodeChoice;
-      }
-      if (addVscode) {
-        const vscodeFiles = {};
-        generateVscodeFiles(vscodeFiles, linter, formatter);
-        for (const [filePath, file] of Object.entries(vscodeFiles)) {
-          const fullPath = join(monorepoRoot, filePath);
-          await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile(fullPath, file.content);
-        }
-        console.log(color.dim("  Generated .vscode/settings.json"));
-        console.log(color.dim("  Generated .vscode/extensions.json"));
-      }
-    }
-    const aiRulesExist = await fileExists(
-      join(monorepoRoot, ".ai/workspace.md")
-    );
-    if (!aiRulesExist) {
-      const platforms = await promptForAiPlatforms(isNonInteractive);
-      if (platforms.length > 0) {
-        const scope = await getMonorepoScope(monorepoRoot);
-        const aiFilesOutput = {};
-        generateAiFiles(aiFilesOutput, {
-          name: scope,
-          packageManager: "pnpm",
-          linter,
-          formatter,
-          isMonorepo: true,
-          platforms
-        });
-        for (const [filePath, file] of Object.entries(aiFilesOutput)) {
-          const fullPath = join(monorepoRoot, filePath);
-          await mkdir(dirname(fullPath), { recursive: true });
-          await writeFile(fullPath, file.content);
-          console.log(color.dim(`  Generated ${filePath}`));
-        }
-      }
-    }
-    process.exit(0);
-  } catch (error) {
-    spinner.stop(color.red("\u2717") + " Failed to fix workspace");
-    console.error(error);
-    process.exit(1);
-  }
-}
-async function handleMigration(config, target, root, options) {
-  const plan = await getMigrationPlan(config, target, root);
-  console.log(color.cyan("Migration:"));
-  if (plan.fromLinter !== plan.toLinter) {
-    console.log(
-      `  Linter: ${color.dim(plan.fromLinter)} \u2192 ${color.green(plan.toLinter)}`
-    );
-  }
-  if (plan.fromFormatter !== plan.toFormatter) {
-    console.log(
-      `  Formatter: ${color.dim(plan.fromFormatter)} \u2192 ${color.green(
-        plan.toFormatter
-      )}`
-    );
-  }
-  console.log();
-  console.log(color.cyan("Changes:"));
-  for (const change of plan.changes) {
-    console.log(formatMigrationChange(change));
-  }
-  if (plan.subPackageUpdates.length > 0) {
-    console.log();
-    console.log(color.cyan(`Sub-packages (${plan.subPackageUpdates.length}):`));
-    for (const update of plan.subPackageUpdates) {
-      const changes = [
-        ...update.remove.map((d) => `-${d}`),
-        ...update.add.map((d) => `+${d}`)
-      ].join(", ");
-      console.log(`  ~ ${update.path} (${changes})`);
-    }
-  }
-  console.log();
-  if (!options.yes) {
-    const confirm = await p.confirm({
-      message: "Apply migration?",
-      initialValue: true
-    });
-    if (p.isCancel(confirm) || !confirm) {
-      console.log(color.dim("  Migration cancelled"));
-      process.exit(0);
-    }
-  }
-  await applyMigration(plan, root);
-  const aiWorkspacePath = join(root, ".ai/workspace.md");
-  const aiRulesExist = await fileExists(aiWorkspacePath);
-  if (aiRulesExist) {
-    console.log();
-    console.log(color.cyan("Updating AI rules..."));
-    const scope = await getMonorepoScope(root);
-    const existingPlatforms = [];
-    if (await fileExists(join(root, "AGENTS.md"))) {
-      existingPlatforms.push("agents");
-    }
-    if (await fileExists(join(root, "CLAUDE.md"))) {
-      existingPlatforms.push("claude");
-    }
-    const aiFilesOutput = {};
-    generateAiFiles(aiFilesOutput, {
-      name: scope,
-      packageManager: "pnpm",
-      linter: plan.toLinter,
-      formatter: plan.toFormatter,
-      isMonorepo: true,
-      platforms: existingPlatforms.length > 0 ? existingPlatforms : ["agents"]
-    });
-    for (const [filePath, file] of Object.entries(aiFilesOutput)) {
-      const fullPath = join(root, filePath);
-      await mkdir(dirname(fullPath), { recursive: true });
-      await writeFile(fullPath, file.content);
-      console.log(color.dim(`  ${filePath}`));
-    }
-  }
-  console.log();
-  console.log(
-    color.green("\u2713") + ` Migrated to ${plan.toLinter}/${plan.toFormatter}`
-  );
-  console.log(color.dim("  Run `pnpm install` to update dependencies"));
-  process.exit(0);
-}
-async function handleUpdateCommand(options) {
-  const monorepoRoot = await detectMonorepoRoot();
-  if (!monorepoRoot) {
-    console.log(color.red("\u2717") + " Not a monorepo workspace");
-    console.log(color.dim("  --update only supports pnpm monorepos"));
-    process.exit(1);
-  }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
-  if (!valid) {
-    console.log(color.yellow("!") + " Workspace has issues:");
-    for (const error of errors) {
-      console.log(color.dim(`  \u2022 ${error}`));
-    }
-    console.log();
-    const shouldFix = options.yes || await p.confirm({
-      message: "Run fix first to resolve these issues?",
-      initialValue: true
-    });
-    if (p.isCancel(shouldFix) || !shouldFix) {
-      console.log(
-        color.dim("  Run `pnpm create krispya --fix` to fix manually")
-      );
-      process.exit(1);
-    }
-    const preFixConfig = await detectCurrentConfig(monorepoRoot);
-    const fixOptions = {
-      ...options,
-      linter: options.linter ?? preFixConfig.linter,
-      formatter: options.formatter ?? preFixConfig.formatter
-    };
-    await handleFixCommand(fixOptions);
-  }
-  const config = await detectCurrentConfig(monorepoRoot);
-  const targetLinter = options.linter;
-  const targetFormatter = options.formatter;
-  const migrationTarget = { linter: targetLinter, formatter: targetFormatter };
-  if (needsMigration(config, migrationTarget)) {
-    await handleMigration(config, migrationTarget, monorepoRoot, options);
-    return;
-  }
-  console.log(
-    color.cyan("Checking for updates...") + color.dim(` (${config.linter}/${config.formatter})`)
-  );
-  console.log();
-  const expected = generateExpectedFiles(config);
-  const categories = await compareWithDisk(expected, monorepoRoot);
-  const workspaceConfigChanges = await getWorkspaceConfigUpdates(monorepoRoot);
-  const workspaceCategory = {
-    category: "workspace-config",
-    label: "Workspace Config",
-    changes: workspaceConfigChanges,
-    hasUserModifications: workspaceConfigChanges.some(
-      (c) => c.status === "modified"
-    )
-  };
-  const allCategories = categories.filter(
-    (c) => c.category !== "workspace-config"
-  );
-  if (workspaceConfigChanges.length > 0) {
-    const configPkgIndex = allCategories.findIndex(
-      (c) => c.category === "config-packages"
-    );
-    if (configPkgIndex !== -1) {
-      allCategories.splice(configPkgIndex + 1, 0, workspaceCategory);
-    } else {
-      allCategories.push(workspaceCategory);
-    }
-  }
-  let updatedCount = 0;
-  let skippedCount = 0;
-  for (const category of allCategories) {
-    const newChanges = category.changes.filter((c) => c.status === "added");
-    const modifiedChanges = category.changes.filter(
-      (c) => c.status === "modified"
-    );
-    const hasNew = newChanges.length > 0;
-    const hasModified = modifiedChanges.length > 0;
-    const hasChanges = hasNew || hasModified;
-    if (!hasChanges) {
-      console.log(color.green("\u2713") + ` ${category.label}: Up to date`);
-      continue;
-    }
-    if (category.category === "ai-files") {
-      if (hasNew) {
-        console.log(color.cyan(category.label + ":"));
-        console.log(
-          color.dim(`  ${newChanges.length} AI file(s) can be added`)
-        );
-        console.log();
-        const applyAi = options.yes ? true : await p.confirm({
-          message: "Add AI rules?",
-          initialValue: true
-        });
-        if (!p.isCancel(applyAi) && applyAi) {
-          await applyUpdates(newChanges, monorepoRoot);
-          console.log(
-            color.green("\u2713") + ` Added ${newChanges.length} AI file(s)`
-          );
-          updatedCount++;
-        } else {
-          console.log(color.dim(`  Skipped ${category.label}`));
-          skippedCount++;
-        }
-      }
-      if (hasModified) {
-        console.log(color.cyan("AI Files (existing):"));
-        for (const change of modifiedChanges) {
-          console.log(formatFileChange(change));
-        }
-        console.log();
-        if (options.yes) {
-          console.log(color.dim("  (--yes mode: keeping existing AI files)"));
-        } else {
-          const updateExisting = await p.confirm({
-            message: "Update existing AI files to latest template?",
-            initialValue: false
-          });
-          if (!p.isCancel(updateExisting) && updateExisting) {
-            await applyUpdates(modifiedChanges, monorepoRoot);
-            console.log(color.green("\u2713") + " Updated existing AI files");
-          }
-        }
-      }
-      console.log();
-      continue;
-    }
-    let changesToApply = [];
-    if (options.yes) {
-      console.log(color.cyan(category.label + ":"));
-      for (const change of [...newChanges, ...modifiedChanges]) {
-        console.log(formatFileChange(change));
-      }
-      console.log();
-      if (category.category === "workspace-config") {
-        changesToApply = [...newChanges, ...modifiedChanges];
-        if (changesToApply.length > 0) {
-          console.log(color.dim("  (--yes mode: applying merge updates)"));
-        }
-      } else {
-        changesToApply = newChanges;
-        if (newChanges.length > 0) {
-          console.log(color.dim("  (--yes mode: adding new files only)"));
-        }
-      }
-    } else if (hasNew && hasModified) {
-      const allChanges = [...newChanges, ...modifiedChanges];
-      const selectedFiles = await p.multiselect({
-        message: `${category.label} (+ new, ~ changed)`,
-        options: allChanges.map((change) => ({
-          value: change.path,
-          label: change.status === "added" ? `+ ${change.path}` : `~ ${change.path}`
-        })),
-        initialValues: newChanges.map((c) => c.path),
-        // Pre-select new files
-        required: false
-      });
-      if (p.isCancel(selectedFiles)) {
-        p.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (selectedFiles.length > 0) {
-        changesToApply = allChanges.filter(
-          (c) => selectedFiles.includes(c.path)
-        );
-      }
-    } else if (hasNew) {
-      console.log(color.cyan(category.label + ":"));
-      for (const change of newChanges) {
-        console.log(formatFileChange(change));
-      }
-      console.log();
-      const shouldAdd = await p.confirm({
-        message: `Add ${newChanges.length} new file(s)?`,
-        initialValue: true
-      });
-      if (p.isCancel(shouldAdd)) {
-        p.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (shouldAdd) {
-        changesToApply = newChanges;
-      }
-    } else if (hasModified) {
-      console.log(color.cyan(category.label + ":"));
-      for (const change of modifiedChanges) {
-        console.log(formatFileChange(change));
-      }
-      console.log();
-      const shouldUpdate = await p.confirm({
-        message: `Update ${modifiedChanges.length} file(s)? (will overwrite)`,
-        initialValue: false
-      });
-      if (p.isCancel(shouldUpdate)) {
-        p.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (shouldUpdate) {
-        changesToApply = modifiedChanges;
-      }
-    }
-    if (changesToApply.length > 0) {
-      await applyUpdates(changesToApply, monorepoRoot);
-      const addedCount = changesToApply.filter(
-        (c) => c.status === "added"
-      ).length;
-      const updatedFilesCount = changesToApply.filter(
-        (c) => c.status === "modified"
-      ).length;
-      const parts = [];
-      if (addedCount > 0) parts.push(`added ${addedCount}`);
-      if (updatedFilesCount > 0) parts.push(`updated ${updatedFilesCount}`);
-      console.log(color.green("\u2713") + ` ${category.label}: ${parts.join(", ")}`);
-      updatedCount++;
-    } else {
-      console.log(color.dim(`  Skipped ${category.label}`));
-      skippedCount++;
-    }
-    console.log();
-  }
-  if (updatedCount === 0 && skippedCount === 0) {
-    console.log(color.green("\u2713") + " Everything is up to date!");
-  } else if (updatedCount > 0) {
-    console.log(
-      color.green("\u2713") + ` Updated ${updatedCount} ${updatedCount === 1 ? "category" : "categories"}`
-    );
-    if (skippedCount > 0) {
-      console.log(color.dim(`  Skipped ${skippedCount}`));
-    }
-  }
-  process.exit(0);
-}
-async function handleWorkspaceCommand(name, options) {
-  const monorepoRoot = await detectMonorepoRoot();
-  if (!monorepoRoot) {
-    console.error(
-      color.red("Error:") + " --workspace flag requires being inside a monorepo"
-    );
-    process.exit(1);
-  }
-  if (!name) {
-    console.error(
-      color.red("Error:") + " Package name is required with --workspace flag"
-    );
-    console.log(
-      color.dim(
-        "  Example: pnpm create krispya my-lib --workspace --type library"
-      )
-    );
-    process.exit(1);
-  }
-  const scope = await getMonorepoScope(monorepoRoot);
-  const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
-  const projectType = options.type ?? "app";
-  const defaultDir = projectType === "library" ? "packages" : "apps";
-  const targetDir = options.dir ?? defaultDir;
-  const template = options.template ?? "vanilla";
-  const baseTemplate = getBaseTemplate(template);
-  const scopedName = name.startsWith("@") ? name : `@${scope}/${name}`;
-  const fullPackagePath = join(monorepoRoot, targetDir, name);
-  try {
-    await access(fullPackagePath, constants$1.F_OK);
-    console.error(
-      color.red("Error:") + ` Directory ${targetDir}/${name} already exists`
-    );
-    process.exit(1);
-  } catch {
-  }
-  const versions = {};
-  const versionPromises = [];
-  const isLibrary = projectType === "library";
-  if (!isLibrary) {
-    versionPromises.push(
-      getLatestNpmVersion("vite", "6.3.4").then((v) => {
-        versions.vite = v;
-      })
-    );
-  }
-  const linter = inheritedSettings.linter ?? options.linter ?? "oxlint";
-  const formatter = inheritedSettings.formatter ?? options.formatter ?? "prettier";
-  const packageManager = inheritedSettings.packageManager ?? "pnpm";
-  const nodeVersion = inheritedSettings.nodeVersion ?? "latest";
-  const pnpmManageVersions = inheritedSettings.pnpmManageVersions ?? true;
-  await Promise.all(versionPromises);
-  const relativePkgPath = join(targetDir, name);
-  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
-  const generateOptions = {
-    name: scopedName,
-    projectType,
-    libraryBundler: isLibrary ? options.bundler ?? "unbuild" : void 0,
-    template,
-    linter,
-    formatter,
-    packageManager,
-    nodeVersion,
-    pnpmManageVersions,
-    workspaceRoot,
-    versions,
-    ...baseTemplate === "r3f" && {
-      drei: options.drei ? {} : void 0,
-      handle: options.handle ? {} : void 0,
-      leva: options.leva ? {} : void 0,
-      postprocessing: options.postprocessing ? {} : void 0,
-      rapier: options.rapier ? {} : void 0,
-      xr: options.xr ? {} : void 0,
-      uikit: options.uikit ? {} : void 0,
-      offscreen: options.offscreen ? {} : void 0,
-      zustand: options.zustand ? {} : void 0,
-      koota: options.koota ? {} : void 0,
-      viverse: options.viverse ? {} : void 0,
-      triplex: options.triplex ? {} : void 0
-    }
-  };
-  console.log(
-    color.cyan("Creating") + ` ${scopedName} in ${targetDir}/${name}...`
-  );
-  try {
-    const files = generate(generateOptions);
-    await writeGeneratedFiles(fullPackagePath, files);
-    console.log(
-      color.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${name}`
-    );
-    process.exit(0);
-  } catch (error) {
-    console.error(color.red("Error:") + " Failed to create package");
-    console.error(String(error));
-    process.exit(1);
-  }
-}
-async function handleMonorepoCreation(generateOptions, isNonInteractive) {
-  const { generateMonorepo } = await import('./chunks/index.mjs').then(function (n) { return n.w; });
-  const packageManager = generateOptions.packageManager || "pnpm";
-  if (packageManager === "pnpm") {
-    generateOptions.pnpmVersion = await getLatestPnpmVersion();
-  } else if (packageManager === "yarn") {
-    generateOptions.yarnVersion = await getLatestYarnVersion();
-  } else if (packageManager === "npm") {
-    generateOptions.npmVersion = await getLatestNpmCliVersion();
-  }
-  const nodeVersion = generateOptions.nodeVersion ?? "latest";
-  if (nodeVersion === "latest") {
-    generateOptions.nodeVersion = await getLatestNodeVersion();
-  }
-  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
-  const projectPath = join(cwd(), generateOptions.name);
-  const spinner = p.spinner();
-  spinner.start("Creating monorepo workspace...");
-  try {
-    const { files } = generateMonorepo({
-      name: generateOptions.name,
-      linter: generateOptions.linter ?? "oxlint",
-      formatter: generateOptions.formatter ?? "prettier",
-      packageManager,
-      pnpmVersion: generateOptions.pnpmVersion,
-      pnpmManageVersions: generateOptions.pnpmManageVersions,
-      nodeVersion: generateOptions.nodeVersion,
-      aiPlatforms: aiPlatforms.length > 0 ? aiPlatforms : void 0
-    });
-    const filePaths = Object.keys(files).sort();
-    for (const filePath of filePaths) {
-      const fullFilePath = join(projectPath, filePath);
-      await mkdir(dirname(fullFilePath), { recursive: true });
-      const file = files[filePath];
-      if (file.type === "text") {
-        await writeFile(fullFilePath, file.content);
-      }
-    }
-    spinner.stop(color.green.inverse(" \u2713 Monorepo workspace created! "));
-    if (isNonInteractive) {
-      process.exit(0);
-    }
-    const newWorkspaceSettings = {
-      linter: generateOptions.linter,
-      formatter: generateOptions.formatter,
-      packageManager,
-      nodeVersion: generateOptions.nodeVersion,
-      pnpmManageVersions: generateOptions.pnpmManageVersions
-    };
-    const scope = generateOptions.name;
-    let addMore = true;
-    while (addMore) {
-      addMore = await createPackageInWorkspace(
-        projectPath,
-        packageManager,
-        newWorkspaceSettings,
-        scope
-      );
-    }
-    const nextSteps = [
-      `cd ${generateOptions.name}`,
-      `${packageManager} install`,
-      `${packageManager} run dev`
-    ].join("\n");
-    p.note(nextSteps, "Next steps");
-    await promptAndOpenEditor(projectPath);
-    p.outro(color.green("Happy coding! \u2728"));
-    process.exit(0);
-  } catch (error) {
-    spinner.stop("Failed to create monorepo workspace");
-    p.log.error(String(error));
-    process.exit(1);
-  }
-}
-async function handleStandaloneProjectCreation(generateOptions, isNonInteractive) {
-  const base = generateOptions.template ? getBaseTemplate(generateOptions.template) : "vanilla";
-  const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
-  generateOptions.name ??= defaultFallbackName;
-  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
-  if (aiPlatforms.length > 0) {
-    generateOptions.aiPlatforms = aiPlatforms;
-  }
-  const packageManager = generateOptions.packageManager || "pnpm";
-  if (packageManager === "pnpm") {
-    generateOptions.pnpmVersion = await getLatestPnpmVersion();
-  } else if (packageManager === "yarn") {
-    generateOptions.yarnVersion = await getLatestYarnVersion();
-  } else if (packageManager === "npm") {
-    generateOptions.npmVersion = await getLatestNpmCliVersion();
-  }
-  const nodeVersion = generateOptions.nodeVersion ?? "latest";
-  if (nodeVersion === "latest") {
-    generateOptions.nodeVersion = await getLatestNodeVersion();
-  }
-  const versions = {};
-  const versionPromises = [];
-  const isLibrary = generateOptions.projectType === "library";
-  const testing = generateOptions.testing ?? (isLibrary ? "vitest" : "none");
-  if (testing === "vitest") {
-    versionPromises.push(
-      getLatestNpmVersion("vitest", "4.0.0").then((v) => {
-        versions.vitest = v;
-      })
-    );
-  }
-  if (!isLibrary) {
-    versionPromises.push(
-      getLatestNpmVersion("vite", "6.3.4").then((v) => {
-        versions.vite = v;
-      })
-    );
-  }
-  const linter = generateOptions.linter ?? "oxlint";
-  if (linter === "eslint") {
-    versionPromises.push(
-      getLatestNpmVersion("eslint", "9.17.0").then((v) => {
-        versions.eslint = v;
-      })
-    );
-  } else if (linter === "oxlint") {
-    versionPromises.push(
-      getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
-        versions.oxlint = v;
-      })
-    );
-  } else if (linter === "biome") {
-    versionPromises.push(
-      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-        versions.biome = v;
-      })
-    );
-  }
-  const formatter = generateOptions.formatter ?? "prettier";
-  if (formatter === "prettier") {
-    versionPromises.push(
-      getLatestNpmVersion("prettier", "3.4.2").then((v) => {
-        versions.prettier = v;
-      })
-    );
-  } else if (formatter === "oxfmt") {
-    versionPromises.push(
-      getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
-        versions.oxfmt = v;
-      })
-    );
-  } else if (formatter === "biome" && linter !== "biome") {
-    versionPromises.push(
-      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-        versions.biome = v;
-      })
-    );
-  }
-  await Promise.all(versionPromises);
-  generateOptions.versions = versions;
-  const projectPath = join(cwd(), generateOptions.name);
-  const spinner = p.spinner();
-  spinner.start("Creating project...");
-  try {
-    const files = generate(generateOptions);
-    await writeGeneratedFiles(projectPath, files);
-    spinner.stop(color.green.inverse(" \u2713 Project created! "));
-    if (isNonInteractive) {
-      process.exit(0);
-    }
-    const nextSteps = isLibrary ? [
-      `cd ${generateOptions.name}`,
-      `${packageManager} install`,
-      `${packageManager} run build`
-    ].join("\n") : [
-      `cd ${generateOptions.name}`,
-      `${packageManager} install`,
-      `${packageManager} run dev`
-    ].join("\n");
-    p.note(nextSteps, "Next steps");
-    await promptAndOpenEditor(projectPath);
-    p.outro(color.green("Happy coding! \u2728"));
-  } catch (error) {
-    spinner.stop("Failed to create project");
-    p.log.error(String(error));
-    process.exit(1);
-  }
-}
-async function handleInteractiveMonorepoMode(monorepoRoot) {
-  const choice = await p.select({
-    message: "Detected monorepo workspace",
-    options: [
-      { value: "add", label: "Add new package to this workspace" },
-      { value: "standalone", label: "Create standalone project" }
-    ],
-    initialValue: "add"
-  });
-  if (p.isCancel(choice)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (choice === "add") {
-    const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
-    const hasSettings = Object.values(inheritedSettings).some(Boolean);
-    if (hasSettings) {
-      const settingsInfo = [
-        inheritedSettings.linter && `linter: ${inheritedSettings.linter}`,
-        inheritedSettings.formatter && `formatter: ${inheritedSettings.formatter}`,
-        inheritedSettings.packageManager && `pm: ${inheritedSettings.packageManager}`
-      ].filter(Boolean).join(", ");
-      p.log.info(`Using workspace settings (${settingsInfo})`);
-    }
-    const scope = await getMonorepoScope(monorepoRoot);
-    let addMore = true;
-    while (addMore) {
-      addMore = await createPackageInWorkspace(
-        monorepoRoot,
-        inheritedSettings.packageManager ?? "pnpm",
-        inheritedSettings,
-        scope
-      );
-    }
-    p.note(
-      [`cd ${monorepoRoot}`, "pnpm install", "pnpm run dev"].join("\n"),
-      "Next steps"
-    );
-    await promptAndOpenEditor(monorepoRoot);
-    p.outro(color.green("Happy coding! \u2728"));
-    process.exit(0);
-  }
-}
-async function main() {
-  const program = new Command().name("create-krispya").description(
-    "CLI for creating Vanilla, React, and React Three Fiber projects"
-  ).argument("[name]", "name for the project").option("--type <type>", "project type: app or library (default: app)").option(
-    "--bundler <bundler>",
-    "library bundler: unbuild or tsdown (default: unbuild, only for libraries)"
-  ).option(
-    "--template <type>",
-    "project template: vanilla, vanilla-js, react, react-js, r3f, r3f-js (default: vanilla)"
-  ).option(
-    "--linter <type>",
-    "linter: eslint, oxlint, or biome (default: oxlint)"
-  ).option(
-    "--formatter <type>",
-    "formatter: prettier, oxfmt, or biome (default: prettier)"
-  ).option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option(
-    "--package-manager <manager>",
-    "specify package manager (e.g. npm, yarn, pnpm)"
-  ).option(
-    "--pnpm-manage-versions",
-    "enable manage-package-manager-versions in pnpm-workspace.yaml (default: true)"
-  ).option(
-    "--no-pnpm-manage-versions",
-    "disable manage-package-manager-versions in pnpm-workspace.yaml"
-  ).option(
-    "--node-version <version>",
-    'set Node.js version for engines.node field (default: "latest")'
-  ).option(
-    "--workspace",
-    "Add package to current monorepo workspace (non-interactive)"
-  ).option(
-    "--dir <directory>",
-    "Target directory for --workspace (default: apps/ or packages/)"
-  ).option("--clear-config", "Clear saved preferences (e.g. editor choice)").option("--config-path", "Print the path to the config file").option(
-    "--check",
-    "Check if current directory is in a valid monorepo workspace"
-  ).option("--fix", "Fix monorepo by generating missing .config packages").option("--update", "Update monorepo workspace to latest configuration").option("-y, --yes", "Non-interactive mode - accept all prompts").option(
-    "--path <directory>",
-    "Run in specified directory instead of current working directory"
-  ).action(async (name, options) => {
-    if (options.path) {
-      process.chdir(options.path);
-    }
-    if (options.clearConfig) {
-      clearConfig();
-      console.log("Configuration cleared.");
-      process.exit(0);
-    }
-    if (options.configPath) {
-      console.log(getConfigPath());
-      process.exit(0);
-    }
-    if (name?.startsWith("-")) {
-      switch (name) {
-        case "--version":
-        case "-V":
-          console.log(pkg.version);
-          process.exit(0);
-        case "--help":
-        case "-h":
-          program.help();
-          break;
-        case "--clear-config":
-          clearConfig();
-          console.log("Configuration cleared.");
-          process.exit(0);
-        case "--config-path":
-          console.log(getConfigPath());
-          process.exit(0);
-        case "--check":
-          await handleCheckCommand();
-          break;
-        case "--fix":
-          options.fix = true;
-          break;
-        case "--update":
-          options.update = true;
-          break;
-        case "--yes":
-          options.yes = true;
-          break;
-        default:
-          console.error(color.red(`Unknown option: ${name}`));
-          process.exit(1);
-      }
-    }
-    if (options.check) {
-      await handleCheckCommand();
-    }
-    if (options.fix) {
-      await handleFixCommand(options);
-    }
-    if (options.update) {
-      await handleUpdateCommand(options);
-    }
-    if (options.dir && !options.workspace) {
-      console.error(color.red("Error:") + " --dir requires --workspace flag");
-      console.log(
-        color.dim(
-          "  Example: pnpm create krispya my-lib --workspace --dir examples"
-        )
-      );
-      process.exit(1);
-    }
-    if (options.workspace) {
-      await handleWorkspaceCommand(name, options);
-    }
-    console.clear();
-    p.intro(color.bgCyan(color.black(` create-krispya v${pkg.version} `)));
-    const monorepoRoot = await detectMonorepoRoot();
-    if (monorepoRoot && !hasConfigOptions(options)) {
-      await handleInteractiveMonorepoMode(monorepoRoot);
-    }
-    let generateOptions;
-    if (options.yes) {
-      const template = options.template ?? "vanilla";
-      const baseTemplate = getBaseTemplate(template);
-      const defaultName = getDefaultProjectName(template);
-      const projectType = options.type ?? "app";
-      generateOptions = {
-        name: name || defaultName,
-        projectType,
-        libraryBundler: projectType === "library" ? options.bundler ?? "unbuild" : void 0,
-        template,
-        linter: options.linter ?? "oxlint",
-        formatter: options.formatter ?? "prettier",
-        ...baseTemplate === "r3f" && {
-          drei: options.drei ? {} : void 0,
-          handle: options.handle ? {} : void 0,
-          leva: options.leva ? {} : void 0,
-          postprocessing: options.postprocessing ? {} : void 0,
-          rapier: options.rapier ? {} : void 0,
-          xr: options.xr ? {} : void 0,
-          uikit: options.uikit ? {} : void 0,
-          offscreen: options.offscreen ? {} : void 0,
-          zustand: options.zustand ? {} : void 0,
-          koota: options.koota ? {} : void 0,
-          viverse: options.viverse ? {} : void 0,
-          triplex: options.triplex ? {} : void 0
-        },
-        packageManager: options.packageManager,
-        pnpmManageVersions: options.pnpmManageVersions,
-        nodeVersion: options.nodeVersion ?? "latest"
-      };
-    } else {
-      const presets = hasConfigOptions(options) ? {
-        type: options.type,
-        template: options.template,
-        bundler: options.bundler,
-        linter: options.linter,
-        formatter: options.formatter,
-        packageManager: options.packageManager,
-        nodeVersion: options.nodeVersion,
-        pnpmManageVersions: options.pnpmManageVersions,
-        drei: options.drei,
-        handle: options.handle,
-        leva: options.leva,
-        postprocessing: options.postprocessing,
-        rapier: options.rapier,
-        xr: options.xr,
-        uikit: options.uikit,
-        offscreen: options.offscreen,
-        zustand: options.zustand,
-        koota: options.koota,
-        triplex: options.triplex,
-        viverse: options.viverse
-      } : void 0;
-      generateOptions = await promptForOptions(name, presets);
-    }
-    const isNonInteractive = options.yes ?? false;
-    if (generateOptions.projectType === "monorepo") {
-      await handleMonorepoCreation(generateOptions, isNonInteractive);
-    } else {
-      await handleStandaloneProjectCreation(generateOptions, isNonInteractive);
-    }
-  });
-  await program.parseAsync();
-}
-main().catch(console.error);