create-krispya 0.7.0 → 0.8.0

package/dist/cli.cjs

@@ -0,0 +1,2826 @@
+#!/usr/bin/env node
+'use strict';
+
+const p = require('@clack/prompts');
+const color = require('chalk');
+const commander = require('commander');
+const node_fs = require('node:fs');
+const promises$1 = require('node:fs/promises');
+const node_module = require('node:module');
+const node_path = require('node:path');
+const node_process = require('node:process');
+const undici = require('undici');
+const child_process = require('child_process');
+const index = require('./chunks/index.cjs');
+const Conf = require('conf');
+const promises = require('fs/promises');
+const fs = require('fs');
+const path = require('path');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const p__namespace = /*#__PURE__*/_interopNamespaceCompat(p);
+const color__default = /*#__PURE__*/_interopDefaultCompat(color);
+const Conf__default = /*#__PURE__*/_interopDefaultCompat(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 ? child_process.spawn(`${editor} ${useReuseFlag ? "-r " : ""}"${path}"`, {
+      detached: true,
+      stdio: "ignore",
+      shell: true
+    }) : child_process.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__default.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 ? index.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 ? index.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 engineInherited = inherited?.engine !== void 0;
+  lines.push(
+    formatRow(
+      "Engine",
+      `${index.getEngineName(options.engine)}@${options.engine?.version ?? "latest"}`,
+      engineInherited
+    )
+  );
+  const pmInherited = inherited?.packageManager !== void 0;
+  lines.push(
+    formatRow("Package manager", index.getPackageManagerName(options.packageManager), pmInherited)
+  );
+  if (index.getPackageManagerName(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 && index.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__default.dim("Integrations"));
+    for (let i = 0; i < integrationNames.length; i += 2) {
+      const left = `${color__default.green("\u25CF")} ${integrationNames[i]}`;
+      const right = integrationNames[i + 1] ? `${color__default.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__default.gray(".".repeat(dotCount));
+    return `${indent}${label} ${dots} ${value}`;
+  };
+  lines.push(
+    formatRow("Engine", `${index.getEngineName(options.engine)}@${options.engine.version ?? "latest"}`)
+  );
+  lines.push(formatRow("Package manager", options.packageManager));
+  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__default({
+  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 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 = index.getBaseTemplate(template);
+  const base = {
+    name,
+    template,
+    projectType,
+    libraryBundler: projectType === "library" ? libraryBundler ?? "unbuild" : void 0,
+    packageManager: inheritedSettings?.packageManager ?? { name: "pnpm" },
+    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
+    engine: inheritedSettings?.engine ?? { name: "node", version: "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 = index.getBaseTemplate(template);
+  switch (base) {
+    case "vanilla":
+      return `vanilla-${index.generateRandomName()}`;
+    case "react":
+      return `react-${index.generateRandomName()}`;
+    case "r3f":
+      return `react-three-${index.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__namespace.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__namespace.isCancel(selected)) {
+    p__namespace.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__namespace.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__namespace.isCancel(bundler)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    libraryBundler = bundler;
+  }
+  let engine = inheritedSettings?.engine ?? presets?.engine ?? { name: "node", version: "latest" };
+  let finalPackageManager = inheritedSettings?.packageManager?.name ?? presets?.packageManager ?? "pnpm";
+  let pnpmManageVersions = inheritedSettings?.pnpmManageVersions ?? presets?.pnpmManageVersions ?? true;
+  if (!inheritedSettings?.engine?.version) {
+    const nodeVersionInput = await p__namespace.text({
+      message: "Node.js version",
+      placeholder: presets?.engine?.version ?? "latest",
+      defaultValue: presets?.engine?.version ?? "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__namespace.isCancel(nodeVersionInput)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    engine = { name: "node", version: nodeVersionInput };
+  }
+  if (!inheritedSettings?.packageManager) {
+    const packageManager = await p__namespace.select({
+      message: "Package manager",
+      options: [
+        { value: "pnpm", label: "pnpm" },
+        { value: "npm", label: "npm" },
+        { value: "yarn", label: "yarn" }
+      ],
+      initialValue: presets?.packageManager ?? "pnpm"
+    });
+    if (p__namespace.isCancel(packageManager)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    finalPackageManager = packageManager;
+    if (packageManager === "pnpm") {
+      const managePnpm = await p__namespace.confirm({
+        message: "Enable manage-package-manager-versions?",
+        initialValue: presets?.pnpmManageVersions ?? true
+      });
+      if (p__namespace.isCancel(managePnpm)) {
+        p__namespace.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__namespace.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__namespace.isCancel(linterChoice)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    linter = linterChoice;
+  }
+  if (!inheritedSettings?.formatter) {
+    const formatterChoice = await p__namespace.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__namespace.isCancel(formatterChoice)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    formatter = formatterChoice;
+  }
+  const testing = await p__namespace.select({
+    message: "Testing",
+    options: [
+      { value: "vitest", label: "Vitest", hint: "fast, Vite-native" },
+      { value: "none", label: "None" }
+    ],
+    initialValue: projectType === "library" ? "vitest" : "none"
+  });
+  if (p__namespace.isCancel(testing)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const language = await p__namespace.select({
+    message: "Language",
+    options: [
+      { value: "typescript", label: "TypeScript" },
+      { value: "javascript", label: "JavaScript" }
+    ],
+    initialValue: "typescript"
+  });
+  if (p__namespace.isCancel(language)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const configStrategyChoice = await p__namespace.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__namespace.isCancel(configStrategyChoice)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const baseTemplate = index.getBaseTemplate(template);
+  const finalTemplate = language === "javascript" ? `${baseTemplate}-js` : baseTemplate;
+  const base = {
+    name,
+    template: finalTemplate,
+    projectType,
+    libraryBundler: projectType === "library" ? libraryBundler : void 0,
+    engine,
+    packageManager: { name: 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__namespace.select({
+    message: "Add an initial package?",
+    options: [
+      { value: "app", label: "Application" },
+      { value: "library", label: "Library" },
+      { value: "skip", label: "Skip" }
+    ],
+    initialValue: "app"
+  });
+  if (p__namespace.isCancel(choice)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return choice;
+}
+function getDefaultMonorepoOptions(name) {
+  return {
+    name,
+    projectType: "monorepo",
+    packageManager: { name: "pnpm" },
+    pnpmManageVersions: true,
+    engine: { name: "node", version: "latest" },
+    linter: "oxlint",
+    formatter: "prettier"
+  };
+}
+async function promptForMonorepoCustomization(name, presets) {
+  const nodeVersion = await p__namespace.text({
+    message: "Node.js version",
+    placeholder: presets?.engine?.version ?? "latest",
+    defaultValue: presets?.engine?.version ?? "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__namespace.isCancel(nodeVersion)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const managePnpm = await p__namespace.confirm({
+    message: "Enable manage-package-manager-versions?",
+    initialValue: presets?.pnpmManageVersions ?? true
+  });
+  if (p__namespace.isCancel(managePnpm)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const linter = await p__namespace.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__namespace.isCancel(linter)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const formatter = await p__namespace.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__namespace.isCancel(formatter)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return {
+    name,
+    projectType: "monorepo",
+    engine: { name: "node", version: nodeVersion },
+    packageManager: { name: "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.engine) defaultOptions.engine = presets.engine;
+    if (presets.pnpmManageVersions !== void 0)
+      defaultOptions.pnpmManageVersions = presets.pnpmManageVersions;
+  }
+  p__namespace.note(
+    formatMonorepoConfigSummary({
+      name: defaultOptions.name,
+      engine: defaultOptions.engine ?? { name: "node", version: "latest" },
+      packageManager: index.getPackageManagerName(defaultOptions.packageManager),
+      pnpmManageVersions: defaultOptions.pnpmManageVersions,
+      linter: defaultOptions.linter ?? "oxlint",
+      formatter: defaultOptions.formatter ?? "prettier"
+    }),
+    "Workspace Configuration"
+  );
+  const proceed = await p__namespace.select({
+    message: "Proceed with these settings?",
+    options: [
+      { value: "continue", label: "Yes, continue" },
+      { value: "customize", label: "No, customize settings" }
+    ],
+    initialValue: "continue"
+  });
+  if (p__namespace.isCancel(proceed)) {
+    p__namespace.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__namespace.text({
+      message: "What is your project named?",
+      placeholder: index.generateRandomName(),
+      defaultValue: index.generateRandomName(),
+      validate: (value) => {
+        if (!value.length) return "Project name is required";
+      }
+    });
+    if (p__namespace.isCancel(nameResult)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    projectName = nameResult;
+  }
+  const projectType = await p__namespace.select({
+    message: "Project type",
+    options: [
+      { value: "app", label: "Application" },
+      { value: "library", label: "Library" },
+      { value: "monorepo", label: "Monorepo" }
+    ],
+    initialValue: presets?.type ?? "app"
+  });
+  if (p__namespace.isCancel(projectType)) {
+    p__namespace.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 ?? { name: "pnpm" },
+    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
+    engine: inheritedSettings?.engine ?? { name: "node", version: "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 ? { name: presets.packageManager } : void 0,
+    engine: presets.engine,
+    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__namespace.select({
+    message: "Select a template",
+    options: allOptions,
+    initialValue: presets?.template ?? "vanilla"
+  });
+  if (p__namespace.isCancel(templateSelection)) {
+    p__namespace.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__namespace.note(formatConfigSummary(defaultOptions2, inheritedSettings), configTitle2);
+    const proceed2 = await p__namespace.select({
+      message: "Proceed with these settings?",
+      options: [
+        { value: "continue", label: "Yes, continue" },
+        { value: "customize", label: "No, customize settings" }
+      ],
+      initialValue: "continue"
+    });
+    if (p__namespace.isCancel(proceed2)) {
+      p__namespace.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 = index.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__namespace.note(formatConfigSummary(defaultOptions, inheritedSettings), configTitle);
+  const proceed = await p__namespace.select({
+    message: "Proceed with these settings?",
+    options: [
+      { value: "continue", label: "Yes, continue" },
+      { value: "customize", label: "No, customize settings" }
+    ],
+    initialValue: "continue"
+  });
+  if (p__namespace.isCancel(proceed)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  if (proceed === "continue") {
+    return defaultOptions;
+  }
+  return promptForCustomization(
+    template,
+    projectName,
+    projectType,
+    integrations,
+    inheritedSettings,
+    presets
+  );
+}
+
+async function detectCurrentConfig(root, isMonorepo = true) {
+  let name = root.split(/[/\\]/).pop() ?? "workspace";
+  let packageManager = "pnpm";
+  try {
+    const pkgPath = path.join(root, "package.json");
+    const content = await promises.readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    if (pkgJson.name) {
+      name = pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
+    }
+    if (pkgJson.packageManager) {
+      packageManager = pkgJson.packageManager.split("@")[0] ?? packageManager;
+    }
+  } catch {
+  }
+  const tooling = await index.detectTooling(root);
+  const configStrategy = isMonorepo ? void 0 : await detectStandaloneConfigStrategy(root);
+  return {
+    name,
+    linter: tooling.linter ?? "oxlint",
+    formatter: tooling.formatter ?? "prettier",
+    packageManager,
+    isMonorepo,
+    configStrategy
+  };
+}
+async function detectStandaloneConfigStrategy(root) {
+  const hasStealthConfig = await Promise.all([
+    fileExists$1(path.join(root, ".config/tsconfig.app.json")),
+    fileExists$1(path.join(root, ".config/tsconfig.node.json")),
+    fileExists$1(path.join(root, ".config/prettier.json")),
+    fileExists$1(path.join(root, ".config/oxlint.json"))
+  ]).then((matches) => matches.some(Boolean));
+  return hasStealthConfig ? "stealth" : "root";
+}
+async function generateExpectedFiles(config) {
+  const { name, linter, formatter, packageManager, isMonorepo, configStrategy } = config;
+  const versions = linter === "biome" || formatter === "biome" ? await index.resolveMonorepoRootPackageVersions({ linter, formatter }) : {};
+  const aiFilesMap = {};
+  index.generateAiFiles(aiFilesMap, {
+    name,
+    packageManager,
+    linter,
+    formatter,
+    isMonorepo,
+    configStrategy,
+    platforms: index.ALL_AI_PLATFORMS
+  });
+  const vscodeFiles = {};
+  index.generateVscodeFiles(vscodeFiles, linter, formatter);
+  const configPackages = {};
+  if (isMonorepo) {
+    index.generateTypescriptConfigPackage(configPackages);
+    if (linter === "oxlint") {
+      index.generateOxlintConfigPackage(configPackages);
+    } else if (linter === "eslint") {
+      index.generateEslintConfigPackage(configPackages);
+    }
+    if (formatter === "oxfmt") {
+      index.generateOxfmtConfigPackage(configPackages);
+    } else if (formatter === "prettier") {
+      index.generatePrettierConfigPackage(configPackages);
+    }
+  }
+  const workspaceConfig = {};
+  const rootConfig = {};
+  rootConfig[".gitignore"] = index.generateGitignore(isMonorepo ? "workspace-root" : "standalone");
+  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 biomeVersion = index.getResolvedPackageVersion(versions, "@biomejs/biome");
+    const biomeConfig = {
+      $schema: `https://biomejs.dev/schemas/${biomeVersion}/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 promises.access(path, fs.constants.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 = path.join(root, filePath);
+      const newContent = file.content;
+      if (await fileExists$1(fullPath)) {
+        const currentContent = await promises.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 = path.join(root, "pnpm-workspace.yaml");
+  const changes = [];
+  let currentContent = "";
+  let exists = false;
+  try {
+    currentContent = await promises.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 = path.join(root, change.path);
+    await promises.mkdir(path.dirname(fullPath), { recursive: true });
+    await promises.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 targetVersions = toLinter === "biome" || toFormatter === "biome" ? await index.resolveMonorepoRootPackageVersions({
+    linter: toLinter,
+    formatter: toFormatter
+  }) : {};
+  const biomeSchemaUrl = toLinter === "biome" || toFormatter === "biome" ? `https://biomejs.dev/schemas/${index.getResolvedPackageVersion(
+    targetVersions,
+    "@biomejs/biome"
+  )}/schema.json` : "";
+  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") {
+        index.generateOxlintConfigPackage(files);
+      } else if (toLinter === "eslint") {
+        index.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: biomeSchemaUrl,
+            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: biomeSchemaUrl,
+            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") {
+        index.generateOxfmtConfigPackage(files);
+      } else if (toFormatter === "prettier") {
+        index.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: biomeSchemaUrl,
+            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 = path.join(root, "pnpm-workspace.yaml");
+  let workspaceContent;
+  try {
+    workspaceContent = await promises.readFile(workspacePath, "utf-8");
+  } catch {
+    return updates;
+  }
+  const packageGlobs = index.parseWorkspaceYamlContent(workspaceContent);
+  for (const glob of packageGlobs) {
+    if (glob.includes(".config")) continue;
+    const baseDir = glob.replace(/\/\*$/, "").replace(/^["']|["']$/g, "");
+    const basePath = path.join(root, baseDir);
+    try {
+      const entries = await promises.readdir(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pkgJsonPath = path.join(basePath, entry.name, "package.json");
+        try {
+          const content = await promises.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: 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 = path.join(root, change.path);
+      try {
+        await promises.rm(fullPath, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  for (const change of plan.changes) {
+    if (change.type === "remove-file") {
+      const fullPath = path.join(root, change.path);
+      try {
+        await promises.rm(fullPath);
+      } catch {
+      }
+    }
+  }
+  for (const change of plan.changes) {
+    if (change.type === "add-file" && change.content) {
+      const fullPath = path.join(root, change.path);
+      await promises.mkdir(path.dirname(fullPath), { recursive: true });
+      await promises.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 = path.join(root, "package.json");
+  const content = await promises.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 resolvedVersions = await index.resolveMonorepoRootPackageVersions({
+    linter: plan.toLinter,
+    formatter: plan.toFormatter
+  });
+  const newLinterDep = LINTER_DEPS[plan.toLinter];
+  devDeps[newLinterDep] = index.formatResolvedPackageVersion(resolvedVersions, newLinterDep);
+  if (plan.toFormatter !== plan.toLinter) {
+    const newFormatterDep = FORMATTER_DEPS[plan.toFormatter];
+    devDeps[newFormatterDep] = index.formatResolvedPackageVersion(resolvedVersions, newFormatterDep);
+  }
+  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 promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+async function updateSubPackageJson(root, update) {
+  const pkgPath = path.join(root, update.path);
+  const content = await promises.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 promises.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}`;
+}
+
+async function checkAnyExists(paths) {
+  for (const path of paths) {
+    try {
+      await promises.access(path, promises.constants.F_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function validateWorkspace(monorepoRoot) {
+  const errors = [];
+  const tsConfigPath = path.join(monorepoRoot, ".config/typescript/package.json");
+  try {
+    await promises.access(tsConfigPath, promises.constants.F_OK);
+  } catch {
+    errors.push("Missing .config/typescript package");
+  }
+  const linterPaths = [
+    path.join(monorepoRoot, ".config/oxlint/package.json"),
+    path.join(monorepoRoot, ".config/eslint/package.json"),
+    path.join(monorepoRoot, "eslint.config.js"),
+    path.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 = [
+    path.join(monorepoRoot, ".config/oxfmt/package.json"),
+    path.join(monorepoRoot, ".config/prettier/package.json"),
+    path.join(monorepoRoot, ".prettierrc.json"),
+    path.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 };
+}
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
+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 promises$1.access(path, node_fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promptForAiPlatforms(isNonInteractive) {
+  const savedPlatforms = getAiPlatforms();
+  if (isNonInteractive) {
+    return savedPlatforms ?? index.ALL_AI_PLATFORMS;
+  }
+  if (savedPlatforms && savedPlatforms.length > 0) {
+    const savedLabels = savedPlatforms.map((plat) => index.AI_PLATFORM_LABELS[plat]).join(", ");
+    const useDefault = await p__namespace.confirm({
+      message: `Add AI rules? ${color__default.dim(`(${savedLabels})`)}`,
+      initialValue: true
+    });
+    if (p__namespace.isCancel(useDefault)) {
+      return [];
+    }
+    if (useDefault) {
+      return savedPlatforms;
+    }
+  }
+  const selected = await p__namespace.multiselect({
+    message: "Add AI rules?",
+    options: index.ALL_AI_PLATFORMS.map((platform) => ({
+      value: platform,
+      label: index.AI_PLATFORM_LABELS[platform],
+      hint: index.AI_PLATFORM_HINTS[platform]
+    })),
+    initialValues: ["agents"],
+    required: false
+  });
+  if (p__namespace.isCancel(selected)) {
+    return [];
+  }
+  const platforms = selected;
+  if (platforms.length === 0) {
+    return [];
+  }
+  return platforms;
+}
+async function writeGeneratedFiles(basePath, files) {
+  const filePaths = Object.keys(files).sort();
+  for (const filePath of filePaths) {
+    const fullFilePath = node_path.join(basePath, filePath);
+    await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
+    const file = files[filePath];
+    if (file.type === "text") {
+      await promises$1.writeFile(fullFilePath, file.content);
+    } else {
+      const response = await undici.fetch(file.url);
+      await promises$1.writeFile(fullFilePath, response.body);
+    }
+  }
+}
+function calculateWorkspaceRoot(packagePath) {
+  const segments = packagePath.split(/[/\\]/).filter(Boolean);
+  return segments.map(() => "..").join("/");
+}
+async function detectMonorepoRoot() {
+  let currentDir = node_process.cwd();
+  const root = node_path.resolve("/");
+  while (currentDir !== root) {
+    const workspaceFile = node_path.join(currentDir, "pnpm-workspace.yaml");
+    try {
+      await promises$1.access(workspaceFile, node_fs.constants.F_OK);
+      const content = await promises$1.readFile(workspaceFile, "utf-8");
+      if (content.includes("packages:")) {
+        return currentDir;
+      }
+    } catch {
+    }
+    currentDir = node_path.dirname(currentDir);
+  }
+  return null;
+}
+async function detectPackageRoot() {
+  let currentDir = node_process.cwd();
+  const root = node_path.resolve("/");
+  while (currentDir !== root) {
+    if (await fileExists(node_path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    currentDir = node_path.dirname(currentDir);
+  }
+  return await fileExists(node_path.join(root, "package.json")) ? root : null;
+}
+async function parseWorkspaceDirectories(monorepoRoot) {
+  try {
+    const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+    const content = await promises$1.readFile(workspaceFile, "utf-8");
+    return index.parseWorkspaceYamlContent(content);
+  } catch {
+    return [];
+  }
+}
+async function detectWorkspaceSettings(monorepoRoot) {
+  try {
+    const tooling = await index.detectTooling(monorepoRoot);
+    const pkgPath = node_path.join(monorepoRoot, "package.json");
+    const content = await promises$1.readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    const packageManager = index.parsePackageManager(pkgJson.packageManager);
+    const engine = index.parseEngine(pkgJson.engines);
+    let pnpmManageVersions;
+    try {
+      const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+      const workspaceContent = await promises$1.readFile(workspaceFile, "utf-8");
+      pnpmManageVersions = workspaceContent.includes("manage-package-manager-versions: true");
+    } catch {
+    }
+    return {
+      linter: tooling.linter,
+      formatter: tooling.formatter,
+      packageManager,
+      engine,
+      pnpmManageVersions
+    };
+  } catch {
+    return {};
+  }
+}
+async function detectExistingConfigs(monorepoRoot) {
+  const configs = {};
+  const eslintPath = node_path.join(monorepoRoot, "eslint.config.js");
+  if (await fileExists(eslintPath)) {
+    configs.linter = "eslint";
+    configs.eslintConfigPath = eslintPath;
+  }
+  const prettierPath = node_path.join(monorepoRoot, ".prettierrc.json");
+  if (await fileExists(prettierPath)) {
+    configs.formatter = "prettier";
+    configs.prettierConfigPath = prettierPath;
+  }
+  const biomePath = node_path.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 = node_path.join(monorepoRoot, "package.json");
+    const content = await promises$1.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 = node_path.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 promises$1.readFile(
+          node_path.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 = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await promises$1.readFile(workspacePath, "utf-8");
+  } catch {
+    content = `packages:
+  - ".config/*"
+  - "packages/*"
+`;
+    await promises$1.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 promises$1.writeFile(workspacePath, content);
+}
+async function migrateEslintConfig(monorepoRoot, files) {
+  const configBasePath = ".config/eslint";
+  const existingConfigPath = node_path.join(monorepoRoot, "eslint.config.js");
+  let existingContent;
+  try {
+    existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
+  } catch {
+    index.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 = node_path.join(monorepoRoot, ".prettierrc.json");
+  let existingContent;
+  try {
+    existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
+  } catch {
+    index.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__namespace.text({
+    message: "Package name?",
+    initialValue: `@${scope}/`,
+    validate: (value) => {
+      const validationError = index.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 = node_path.join(monorepoRoot, defaultDir, dirName);
+        try {
+          const { statSync } = require$1("fs");
+          statSync(targetPath);
+          return `Directory ${defaultDir}/${dirName} already exists`;
+        } catch {
+        }
+      }
+    }
+  });
+  if (p__namespace.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__namespace.select({
+      message: "Target directory",
+      options: workspaceDirectories.map((dir) => ({
+        value: dir,
+        label: dir
+      })),
+      initialValue: workspaceDirectories.includes(defaultDir) ? defaultDir : workspaceDirectories[0]
+    });
+    if (p__namespace.isCancel(dirChoice)) {
+      return false;
+    }
+    targetDir = dirChoice;
+    const targetPath = node_path.join(monorepoRoot, targetDir, shortName);
+    try {
+      const { statSync } = require$1("fs");
+      statSync(targetPath);
+      p__namespace.log.error(`Directory ${targetDir}/${shortName} already exists`);
+      return false;
+    } catch {
+    }
+  }
+  const relativePkgPath = node_path.join(targetDir, shortName);
+  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
+  packageOptions.workspaceRoot = workspaceRoot;
+  packageOptions.name = scopedName;
+  packageOptions.packageManager = await index.resolvePackageManager(packageOptions);
+  packageOptions.engine = await index.resolveEngine(packageOptions);
+  packageOptions.versions = await index.resolveProjectPackageVersions(packageOptions);
+  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
+  if (workspacePackages.length > 0) {
+    const selectedDeps = await p__namespace.multiselect({
+      message: "Add workspace dependencies?",
+      options: workspacePackages.map((name) => ({ value: name, label: name })),
+      required: false
+    });
+    if (!p__namespace.isCancel(selectedDeps) && selectedDeps.length > 0) {
+      packageOptions.workspaceDependencies = selectedDeps;
+    }
+  }
+  const outputPath = node_path.join(monorepoRoot, relativePkgPath);
+  const spinner = p__namespace.spinner();
+  spinner.start("Creating package...");
+  try {
+    const files = index.generate(packageOptions);
+    await writeGeneratedFiles(outputPath, files);
+    spinner.stop(color__default.green.inverse(` \u2713 Package created at ${relativePkgPath}! `));
+    const addAnother = await p__namespace.select({
+      message: "Add another package?",
+      options: [
+        { value: "no", label: "No, I'm done" },
+        { value: "yes", label: "Yes, add another" }
+      ],
+      initialValue: "no"
+    });
+    return !p__namespace.isCancel(addAnother) && addAnother === "yes";
+  } catch (error) {
+    spinner.stop("Failed to create package");
+    p__namespace.log.error(String(error));
+    return false;
+  }
+}
+async function promptAndOpenEditor(projectPath) {
+  const savedEditor = getPreferredEditor();
+  let selectedEditor;
+  if (savedEditor && savedEditor !== "skip") {
+    const useDefault = await p__namespace.confirm({
+      message: `Open in editor? ${color__default.dim(`(${editorNames[savedEditor]})`)}`,
+      initialValue: true
+    });
+    if (p__namespace.isCancel(useDefault)) {
+      selectedEditor = void 0;
+    } else if (useDefault) {
+      selectedEditor = savedEditor;
+    } else {
+      selectedEditor = "skip";
+    }
+  } else {
+    const openEditor = await p__namespace.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__namespace.isCancel(openEditor)) {
+      selectedEditor = openEditor;
+      const saveChoice = await p__namespace.confirm({
+        message: `Save ${editorNames[selectedEditor] ?? "Skip"} as default editor?`,
+        initialValue: true
+      });
+      if (!p__namespace.isCancel(saveChoice) && saveChoice) {
+        setPreferredEditor(selectedEditor);
+        if (selectedEditor === "cursor" || selectedEditor === "code") {
+          const reuseChoice = await p__namespace.confirm({
+            message: "Reuse current window when opening projects?",
+            initialValue: false
+          });
+          if (!p__namespace.isCancel(reuseChoice)) {
+            setReuseWindow(reuseChoice);
+          }
+        }
+      }
+    }
+  }
+  if (selectedEditor && selectedEditor !== "skip") {
+    try {
+      await openInEditor(
+        selectedEditor,
+        projectPath,
+        getReuseWindow()
+      );
+      p__namespace.log.success(`Opening in ${editorNames[selectedEditor]}...`);
+    } catch {
+      p__namespace.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__default.red("\u2717") + " Not a monorepo workspace");
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color__default.green("\u2713") + " Valid monorepo workspace");
+    console.log(color__default.dim(`  ${monorepoRoot}`));
+  } else {
+    console.log(color__default.red("\u2717") + " Invalid monorepo workspace");
+    console.log(color__default.dim(`  ${monorepoRoot}`));
+    for (const error of errors) {
+      console.log(color__default.red(`  \u2022 ${error}`));
+    }
+  }
+  process.exit(valid ? 0 : 1);
+}
+async function handleFixCommand(options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color__default.red("\u2717") + " Not a monorepo workspace");
+    console.log(color__default.dim("  Run this command from within a monorepo"));
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color__default.green("\u2713") + " Workspace is already valid");
+    console.log(color__default.dim(`  ${monorepoRoot}`));
+    process.exit(0);
+  }
+  console.log(color__default.yellow("!") + " Invalid monorepo workspace");
+  for (const error of errors) {
+    console.log(color__default.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__namespace.select({
+      message: "Linter",
+      options: [
+        {
+          value: "oxlint",
+          label: "oxlint" + (tooling.linter === "oxlint" ? color__default.dim(" (installed)") : "")
+        },
+        {
+          value: "eslint",
+          label: "eslint" + (tooling.linter === "eslint" || existingConfigs.linter === "eslint" ? color__default.dim(" (installed)") : "")
+        },
+        {
+          value: "biome",
+          label: "biome" + (tooling.linter === "biome" ? color__default.dim(" (installed)") : "")
+        }
+      ],
+      initialValue: detectedLinter
+    });
+    if (p__namespace.isCancel(linterChoice)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const formatterChoice = await p__namespace.select({
+      message: "Formatter",
+      options: [
+        {
+          value: "oxfmt",
+          label: "oxfmt" + (tooling.formatter === "oxfmt" ? color__default.dim(" (installed)") : "")
+        },
+        {
+          value: "prettier",
+          label: "prettier" + (tooling.formatter === "prettier" || existingConfigs.formatter === "prettier" ? color__default.dim(" (installed)") : "")
+        },
+        {
+          value: "biome",
+          label: "biome" + (tooling.formatter === "biome" ? color__default.dim(" (installed)") : "")
+        }
+      ],
+      initialValue: detectedFormatter
+    });
+    if (p__namespace.isCancel(formatterChoice)) {
+      p__namespace.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    linter = linterChoice;
+    formatter = formatterChoice;
+  }
+  console.log();
+  const spinner = p__namespace.spinner();
+  spinner.start("Fixing workspace...");
+  try {
+    const files = {};
+    const tsConfigExists = await fileExists(
+      node_path.join(monorepoRoot, ".config/typescript/package.json")
+    );
+    if (!tsConfigExists) {
+      index.generateTypescriptConfigPackage(files);
+    }
+    if (linter === "oxlint") {
+      const oxlintExists = await fileExists(node_path.join(monorepoRoot, ".config/oxlint/package.json"));
+      if (!oxlintExists) index.generateOxlintConfigPackage(files);
+    } else if (linter === "eslint") {
+      const eslintPkgExists = await fileExists(
+        node_path.join(monorepoRoot, ".config/eslint/package.json")
+      );
+      if (!eslintPkgExists) {
+        if (existingConfigs.eslintConfigPath) {
+          await migrateEslintConfig(monorepoRoot, files);
+        } else {
+          index.generateEslintConfigPackage(files);
+        }
+      }
+    }
+    if (formatter === "oxfmt") {
+      const oxfmtExists = await fileExists(node_path.join(monorepoRoot, ".config/oxfmt/package.json"));
+      if (!oxfmtExists) index.generateOxfmtConfigPackage(files);
+    } else if (formatter === "prettier") {
+      const prettierPkgExists = await fileExists(
+        node_path.join(monorepoRoot, ".config/prettier/package.json")
+      );
+      if (!prettierPkgExists) {
+        if (existingConfigs.prettierConfigPath) {
+          await migratePrettierConfig(monorepoRoot, files);
+        } else {
+          index.generatePrettierConfigPackage(files);
+        }
+      }
+    }
+    if ((linter === "biome" || formatter === "biome") && !existingConfigs.biomeConfigPath) {
+      const versions = await index.resolveMonorepoRootPackageVersions({
+        linter,
+        formatter
+      });
+      const biomeVersion = index.getResolvedPackageVersion(versions, "@biomejs/biome");
+      const biomeConfig = {
+        $schema: `https://biomejs.dev/schemas/${biomeVersion}/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 = node_path.join(monorepoRoot, filePath);
+      await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
+      await promises$1.writeFile(fullPath, file.content);
+    }
+    await ensureConfigInWorkspace(monorepoRoot);
+    if (existingConfigs.eslintConfigPath && linter === "eslint") {
+      try {
+        await promises$1.unlink(existingConfigs.eslintConfigPath);
+      } catch {
+      }
+    }
+    if (existingConfigs.prettierConfigPath && formatter === "prettier") {
+      try {
+        await promises$1.unlink(existingConfigs.prettierConfigPath);
+      } catch {
+      }
+    }
+    spinner.stop(color__default.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__default.dim(`  Generated ${pkgName}`));
+    }
+    const vscodeSettingsExists = await fileExists(node_path.join(monorepoRoot, ".vscode/settings.json"));
+    const vscodeExtensionsExists = await fileExists(
+      node_path.join(monorepoRoot, ".vscode/extensions.json")
+    );
+    const vscodeExists = vscodeSettingsExists && vscodeExtensionsExists;
+    if (!vscodeExists) {
+      let addVscode = false;
+      if (isNonInteractive) {
+        addVscode = true;
+      } else {
+        const vscodeChoice = await p__namespace.confirm({
+          message: "Generate VS Code settings?",
+          initialValue: true
+        });
+        addVscode = !p__namespace.isCancel(vscodeChoice) && vscodeChoice;
+      }
+      if (addVscode) {
+        const vscodeFiles = {};
+        index.generateVscodeFiles(vscodeFiles, linter, formatter);
+        for (const [filePath, file] of Object.entries(vscodeFiles)) {
+          const fullPath = node_path.join(monorepoRoot, filePath);
+          await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
+          await promises$1.writeFile(fullPath, file.content);
+        }
+        console.log(color__default.dim("  Generated .vscode/settings.json"));
+        console.log(color__default.dim("  Generated .vscode/extensions.json"));
+      }
+    }
+    const aiRulesExist = await fileExists(node_path.join(monorepoRoot, ".ai/workspace.md"));
+    if (!aiRulesExist) {
+      const platforms = await promptForAiPlatforms(isNonInteractive);
+      if (platforms.length > 0) {
+        const scope = await getMonorepoScope(monorepoRoot);
+        const aiFilesOutput = {};
+        index.generateAiFiles(aiFilesOutput, {
+          name: scope,
+          packageManager: "pnpm",
+          linter,
+          formatter,
+          isMonorepo: true,
+          platforms
+        });
+        for (const [filePath, file] of Object.entries(aiFilesOutput)) {
+          const fullPath = node_path.join(monorepoRoot, filePath);
+          await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
+          await promises$1.writeFile(fullPath, file.content);
+          console.log(color__default.dim(`  Generated ${filePath}`));
+        }
+      }
+    }
+    process.exit(0);
+  } catch (error) {
+    spinner.stop(color__default.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__default.cyan("Migration:"));
+  if (plan.fromLinter !== plan.toLinter) {
+    console.log(`  Linter: ${color__default.dim(plan.fromLinter)} \u2192 ${color__default.green(plan.toLinter)}`);
+  }
+  if (plan.fromFormatter !== plan.toFormatter) {
+    console.log(
+      `  Formatter: ${color__default.dim(plan.fromFormatter)} \u2192 ${color__default.green(plan.toFormatter)}`
+    );
+  }
+  console.log();
+  console.log(color__default.cyan("Changes:"));
+  for (const change of plan.changes) {
+    console.log(formatMigrationChange(change));
+  }
+  if (plan.subPackageUpdates.length > 0) {
+    console.log();
+    console.log(color__default.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__namespace.confirm({
+      message: "Apply migration?",
+      initialValue: true
+    });
+    if (p__namespace.isCancel(confirm) || !confirm) {
+      console.log(color__default.dim("  Migration cancelled"));
+      process.exit(0);
+    }
+  }
+  await applyMigration(plan, root);
+  const aiWorkspacePath = node_path.join(root, ".ai/workspace.md");
+  const aiRulesExist = await fileExists(aiWorkspacePath);
+  if (aiRulesExist) {
+    console.log();
+    console.log(color__default.cyan("Updating AI rules..."));
+    const scope = await getMonorepoScope(root);
+    const existingPlatforms = [];
+    if (await fileExists(node_path.join(root, "AGENTS.md"))) {
+      existingPlatforms.push("agents");
+    }
+    if (await fileExists(node_path.join(root, "CLAUDE.md"))) {
+      existingPlatforms.push("claude");
+    }
+    const aiFilesOutput = {};
+    index.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 = node_path.join(root, filePath);
+      await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
+      await promises$1.writeFile(fullPath, file.content);
+      console.log(color__default.dim(`  ${filePath}`));
+    }
+  }
+  console.log();
+  console.log(color__default.green("\u2713") + ` Migrated to ${plan.toLinter}/${plan.toFormatter}`);
+  console.log(color__default.dim("  Run `pnpm install` to update dependencies"));
+  process.exit(0);
+}
+async function handleUpdateCommand(options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  const projectRoot = monorepoRoot ?? await detectPackageRoot();
+  if (!projectRoot) {
+    console.log(color__default.red("\u2717") + " Could not find a project root");
+    console.log(color__default.dim("  Run this command from inside a generated project"));
+    process.exit(1);
+  }
+  const isMonorepo = monorepoRoot != null;
+  if (isMonorepo) {
+    const { valid, errors } = await validateWorkspace(projectRoot);
+    if (!valid) {
+      console.log(color__default.yellow("!") + " Workspace has issues:");
+      for (const error of errors) {
+        console.log(color__default.dim(`  \u2022 ${error}`));
+      }
+      console.log();
+      const shouldFix = options.yes || await p__namespace.confirm({
+        message: "Run fix first to resolve these issues?",
+        initialValue: true
+      });
+      if (p__namespace.isCancel(shouldFix) || !shouldFix) {
+        console.log(color__default.dim("  Run `pnpm create krispya --fix` to fix manually"));
+        process.exit(1);
+      }
+      const preFixConfig = await detectCurrentConfig(projectRoot);
+      const fixOptions = {
+        ...options,
+        linter: options.linter ?? preFixConfig.linter,
+        formatter: options.formatter ?? preFixConfig.formatter
+      };
+      await handleFixCommand(fixOptions);
+    }
+  } else if (options.linter || options.formatter) {
+    console.log(
+      color__default.yellow("!") + " Linter/formatter migrations in --update are currently monorepo-only"
+    );
+    console.log(color__default.dim("  Continuing with standalone shared config updates"));
+    console.log();
+  }
+  const config = await detectCurrentConfig(projectRoot, isMonorepo);
+  const targetLinter = options.linter;
+  const targetFormatter = options.formatter;
+  const migrationTarget = { linter: targetLinter, formatter: targetFormatter };
+  if (isMonorepo && needsMigration(config, migrationTarget)) {
+    await handleMigration(config, migrationTarget, projectRoot, options);
+    return;
+  }
+  console.log(
+    color__default.cyan("Checking for updates...") + color__default.dim(` (${config.linter}/${config.formatter})`)
+  );
+  console.log();
+  const expected = await generateExpectedFiles(config);
+  const categories = await compareWithDisk(expected, projectRoot);
+  const allCategories = categories.filter((c) => c.category !== "workspace-config");
+  if (isMonorepo) {
+    const workspaceConfigChanges = await getWorkspaceConfigUpdates(projectRoot);
+    const workspaceCategory = {
+      category: "workspace-config",
+      label: "Workspace Config",
+      changes: workspaceConfigChanges,
+      hasUserModifications: workspaceConfigChanges.some((c) => c.status === "modified")
+    };
+    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__default.green("\u2713") + ` ${category.label}: Up to date`);
+      continue;
+    }
+    if (category.category === "ai-files") {
+      if (hasNew) {
+        console.log(color__default.cyan(category.label + ":"));
+        console.log(color__default.dim(`  ${newChanges.length} AI file(s) can be added`));
+        console.log();
+        const applyAi = options.yes ? true : await p__namespace.confirm({
+          message: "Add AI rules?",
+          initialValue: true
+        });
+        if (!p__namespace.isCancel(applyAi) && applyAi) {
+          await applyUpdates(newChanges, projectRoot);
+          console.log(color__default.green("\u2713") + ` Added ${newChanges.length} AI file(s)`);
+          updatedCount++;
+        } else {
+          console.log(color__default.dim(`  Skipped ${category.label}`));
+          skippedCount++;
+        }
+      }
+      if (hasModified) {
+        console.log(color__default.cyan("AI Files (existing):"));
+        for (const change of modifiedChanges) {
+          console.log(formatFileChange(change));
+        }
+        console.log();
+        if (options.yes) {
+          console.log(color__default.dim("  (--yes mode: keeping existing AI files)"));
+        } else {
+          const updateExisting = await p__namespace.confirm({
+            message: "Update existing AI files to latest template?",
+            initialValue: false
+          });
+          if (!p__namespace.isCancel(updateExisting) && updateExisting) {
+            await applyUpdates(modifiedChanges, projectRoot);
+            console.log(color__default.green("\u2713") + " Updated existing AI files");
+          }
+        }
+      }
+      console.log();
+      continue;
+    }
+    let changesToApply = [];
+    if (options.yes) {
+      console.log(color__default.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__default.dim("  (--yes mode: applying merge updates)"));
+        }
+      } else {
+        changesToApply = newChanges;
+        if (newChanges.length > 0) {
+          console.log(color__default.dim("  (--yes mode: adding new files only)"));
+        }
+      }
+    } else if (hasNew && hasModified) {
+      const allChanges = [...newChanges, ...modifiedChanges];
+      const selectedFiles = await p__namespace.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__namespace.isCancel(selectedFiles)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (selectedFiles.length > 0) {
+        changesToApply = allChanges.filter((c) => selectedFiles.includes(c.path));
+      }
+    } else if (hasNew) {
+      console.log(color__default.cyan(category.label + ":"));
+      for (const change of newChanges) {
+        console.log(formatFileChange(change));
+      }
+      console.log();
+      const shouldAdd = await p__namespace.confirm({
+        message: `Add ${newChanges.length} new file(s)?`,
+        initialValue: true
+      });
+      if (p__namespace.isCancel(shouldAdd)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (shouldAdd) {
+        changesToApply = newChanges;
+      }
+    } else if (hasModified) {
+      console.log(color__default.cyan(category.label + ":"));
+      for (const change of modifiedChanges) {
+        console.log(formatFileChange(change));
+      }
+      console.log();
+      const shouldUpdate = await p__namespace.confirm({
+        message: `Update ${modifiedChanges.length} file(s)? (will overwrite)`,
+        initialValue: false
+      });
+      if (p__namespace.isCancel(shouldUpdate)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (shouldUpdate) {
+        changesToApply = modifiedChanges;
+      }
+    }
+    if (changesToApply.length > 0) {
+      await applyUpdates(changesToApply, projectRoot);
+      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__default.green("\u2713") + ` ${category.label}: ${parts.join(", ")}`);
+      updatedCount++;
+    } else {
+      console.log(color__default.dim(`  Skipped ${category.label}`));
+      skippedCount++;
+    }
+    console.log();
+  }
+  if (updatedCount === 0 && skippedCount === 0) {
+    console.log(color__default.green("\u2713") + " Everything is up to date!");
+  } else if (updatedCount > 0) {
+    console.log(
+      color__default.green("\u2713") + ` Updated ${updatedCount} ${updatedCount === 1 ? "category" : "categories"}`
+    );
+    if (skippedCount > 0) {
+      console.log(color__default.dim(`  Skipped ${skippedCount}`));
+    }
+  }
+  process.exit(0);
+}
+async function handleWorkspaceCommand(name, options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.error(color__default.red("Error:") + " --workspace flag requires being inside a monorepo");
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(color__default.red("Error:") + " Package name is required with --workspace flag");
+    console.log(color__default.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 = index.getBaseTemplate(template);
+  const scopedName = name.startsWith("@") ? name : `@${scope}/${name}`;
+  const fullPackagePath = node_path.join(monorepoRoot, targetDir, name);
+  try {
+    await promises$1.access(fullPackagePath, node_fs.constants.F_OK);
+    console.error(color__default.red("Error:") + ` Directory ${targetDir}/${name} already exists`);
+    process.exit(1);
+  } catch {
+  }
+  const linter = inheritedSettings.linter ?? options.linter ?? "oxlint";
+  const formatter = inheritedSettings.formatter ?? options.formatter ?? "prettier";
+  const packageManager = inheritedSettings.packageManager?.name ?? "pnpm";
+  const engine = inheritedSettings.engine ?? {
+    name: "node",
+    version: "latest"
+  };
+  const pnpmManageVersions = inheritedSettings.pnpmManageVersions ?? true;
+  const isLibrary = projectType === "library";
+  const relativePkgPath = node_path.join(targetDir, name);
+  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
+  const generateOptions = {
+    name: scopedName,
+    projectType,
+    libraryBundler: isLibrary ? options.bundler ?? "unbuild" : void 0,
+    template,
+    linter,
+    formatter,
+    packageManager: { name: packageManager },
+    engine,
+    pnpmManageVersions,
+    workspaceRoot,
+    ...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
+    }
+  };
+  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
+  generateOptions.engine = await index.resolveEngine(generateOptions);
+  generateOptions.versions = await index.resolveProjectPackageVersions(generateOptions);
+  console.log(color__default.cyan("Creating") + ` ${scopedName} in ${targetDir}/${name}...`);
+  try {
+    const files = index.generate(generateOptions);
+    await writeGeneratedFiles(fullPackagePath, files);
+    console.log(color__default.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${name}`);
+    process.exit(0);
+  } catch (error) {
+    console.error(color__default.red("Error:") + " Failed to create package");
+    console.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleMonorepoCreation(generateOptions, isNonInteractive) {
+  const { generateMonorepo } = await import('./chunks/index.cjs').then(function (n) { return n.monorepo; });
+  const packageManager = index.getPackageManagerName(generateOptions.packageManager);
+  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
+  generateOptions.engine = await index.resolveEngine(generateOptions);
+  generateOptions.versions = await index.resolveMonorepoRootPackageVersions({
+    linter: generateOptions.linter ?? "oxlint",
+    formatter: generateOptions.formatter ?? "prettier",
+    versions: generateOptions.versions
+  });
+  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
+  const projectPath = node_path.join(node_process.cwd(), generateOptions.name);
+  const spinner = p__namespace.spinner();
+  spinner.start("Creating monorepo workspace...");
+  try {
+    const { files } = generateMonorepo({
+      name: generateOptions.name,
+      linter: generateOptions.linter ?? "oxlint",
+      formatter: generateOptions.formatter ?? "prettier",
+      packageManager: generateOptions.packageManager ?? {
+        name: packageManager
+      },
+      pnpmManageVersions: generateOptions.pnpmManageVersions,
+      engine: generateOptions.engine,
+      versions: generateOptions.versions,
+      aiPlatforms: aiPlatforms.length > 0 ? aiPlatforms : void 0
+    });
+    const filePaths = Object.keys(files).sort();
+    for (const filePath of filePaths) {
+      const fullFilePath = node_path.join(projectPath, filePath);
+      await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
+      const file = files[filePath];
+      if (file.type === "text") {
+        await promises$1.writeFile(fullFilePath, file.content);
+      }
+    }
+    spinner.stop(color__default.green.inverse(" \u2713 Monorepo workspace created! "));
+    if (isNonInteractive) {
+      process.exit(0);
+    }
+    const newWorkspaceSettings = {
+      linter: generateOptions.linter,
+      formatter: generateOptions.formatter,
+      packageManager: generateOptions.packageManager ?? {
+        name: packageManager
+      },
+      engine: generateOptions.engine,
+      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__namespace.note(nextSteps, "Next steps");
+    await promptAndOpenEditor(projectPath);
+    p__namespace.outro(color__default.green("Happy coding! \u2728"));
+    process.exit(0);
+  } catch (error) {
+    spinner.stop("Failed to create monorepo workspace");
+    p__namespace.log.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleStandaloneProjectCreation(generateOptions, isNonInteractive) {
+  const base = generateOptions.template ? index.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 = index.getPackageManagerName(generateOptions.packageManager);
+  const isLibrary = generateOptions.projectType === "library";
+  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
+  generateOptions.engine = await index.resolveEngine(generateOptions);
+  generateOptions.versions = await index.resolveProjectPackageVersions(generateOptions);
+  const projectPath = node_path.join(node_process.cwd(), generateOptions.name);
+  const spinner = p__namespace.spinner();
+  spinner.start("Creating project...");
+  try {
+    const files = index.generate(generateOptions);
+    await writeGeneratedFiles(projectPath, files);
+    spinner.stop(color__default.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__namespace.note(nextSteps, "Next steps");
+    await promptAndOpenEditor(projectPath);
+    p__namespace.outro(color__default.green("Happy coding! \u2728"));
+  } catch (error) {
+    spinner.stop("Failed to create project");
+    p__namespace.log.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleInteractiveMonorepoMode(monorepoRoot) {
+  const choice = await p__namespace.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__namespace.isCancel(choice)) {
+    p__namespace.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.name}`
+      ].filter(Boolean).join(", ");
+      p__namespace.log.info(`Using workspace settings (${settingsInfo})`);
+    }
+    const scope = await getMonorepoScope(monorepoRoot);
+    let addMore = true;
+    while (addMore) {
+      addMore = await createPackageInWorkspace(
+        monorepoRoot,
+        inheritedSettings.packageManager?.name ?? "pnpm",
+        inheritedSettings,
+        scope
+      );
+    }
+    p__namespace.note([`cd ${monorepoRoot}`, "pnpm install", "pnpm run dev"].join("\n"), "Next steps");
+    await promptAndOpenEditor(monorepoRoot);
+    p__namespace.outro(color__default.green("Happy coding! \u2728"));
+    process.exit(0);
+  }
+}
+async function main() {
+  const program = new commander.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__default.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__default.red("Error:") + " --dir requires --workspace flag");
+      console.log(
+        color__default.dim("  Example: pnpm create krispya my-lib --workspace --dir examples")
+      );
+      process.exit(1);
+    }
+    if (options.workspace) {
+      await handleWorkspaceCommand(name, options);
+    }
+    console.clear();
+    p__namespace.intro(color__default.bgCyan(color__default.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 = index.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 ? { name: options.packageManager } : void 0,
+        pnpmManageVersions: options.pnpmManageVersions,
+        engine: { name: "node", version: 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,
+        engine: options.nodeVersion ? { name: "node", version: options.nodeVersion } : void 0,
+        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);