create-krispya 0.5.0 → 0.5.2

package/dist/cli.mjs

@@ -2,14 +2,14 @@
 import { createRequire } from 'module';
 import { cwd } from 'process';
 import { join, dirname, resolve } from 'path';
-import { mkdir, writeFile, access, readFile } from 'fs/promises';
-import { constants } from 'fs';
+import { access, constants, mkdir, writeFile, unlink, readFile } from 'fs/promises';
+import { constants as constants$1 } from 'fs';
 import { Command } from 'commander';
 import * as p from '@clack/prompts';
 import color from 'chalk';
 import { fetch } from 'undici';
 import { spawn } from 'child_process';
-import { g as getBaseTemplate, a as getLanguageFromTemplate, b as generateRandomName, c as getLatestPnpmVersion, d as getLatestNodeVersion, e as getLatestNpmVersion, f as generate } from './chunks/index.mjs';
+import { g as getBaseTemplate, a as getLanguageFromTemplate, b as generateRandomName, c as generateTypescriptConfigPackage, d as generateOxlintConfigPackage, e as generateEslintConfigPackage, f as generateOxfmtConfigPackage, h as generatePrettierConfigPackage, i as generateVscodeFiles, j as generateAiFiles, k as getLatestNpmVersion, l as generate, m as getLatestPnpmVersion, n as getLatestYarnVersion, o as getLatestNpmCliVersion, p as getLatestNodeVersion, v as validatePackageName, q as parseWorkspaceYamlContent } from './chunks/index.mjs';
 import Conf from 'conf';
 
 const editorNames = {
@@ -123,7 +123,38 @@ function formatMonorepoConfigSummary(options) {
   return lines.join("\n");
 }
 
-function getDefaultOptions(template, name, projectType = "app", libraryBundler) {
+const config = new Conf({
+  projectName: "create-krispya"
+});
+function getPreferredEditor() {
+  return config.get("preferredEditor");
+}
+function setPreferredEditor(editor) {
+  config.set("preferredEditor", editor);
+}
+function getReuseWindow() {
+  return config.get("reuseWindow") ?? false;
+}
+function setReuseWindow(reuse) {
+  config.set("reuseWindow", reuse);
+}
+function getAiFiles() {
+  return config.get("aiFiles");
+}
+function setAiFiles(files) {
+  config.set("aiFiles", files);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+function getCustomTemplates() {
+  return config.get("customTemplates") ?? {};
+}
+
+function getDefaultOptions(template, name, projectType = "app", libraryBundler, integrations, inheritedTooling) {
   const baseTemplate = getBaseTemplate(template);
   const base = {
     name,
@@ -133,26 +164,26 @@ function getDefaultOptions(template, name, projectType = "app", libraryBundler)
     packageManager: "pnpm",
     pnpmManageVersions: true,
     nodeVersion: "latest",
-    linter: "oxlint",
-    formatter: "oxfmt",
+    linter: inheritedTooling?.linter ?? "oxlint",
+    formatter: inheritedTooling?.formatter ?? "oxfmt",
     // Libraries get vitest by default, apps don't
     testing: projectType === "library" ? "vitest" : "none"
   };
-  if (baseTemplate === "r3f") {
+  if (baseTemplate === "r3f" && integrations) {
     return {
       ...base,
-      drei: {},
-      handle: {},
-      leva: {},
-      postprocessing: {},
-      rapier: {},
-      xr: {},
-      uikit: {},
-      offscreen: {},
-      zustand: {},
-      koota: {},
-      triplex: {},
-      viverse: {}
+      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;
@@ -168,7 +199,33 @@ function getDefaultProjectName(template) {
       return `react-three-${generateRandomName()}`;
   }
 }
-async function promptForCustomization(template, name, projectType) {
+async function promptForR3fIntegrations() {
+  const selected = await p.multiselect({
+    message: "R3F integrations",
+    options: [
+      { value: "drei", label: "Drei" },
+      { value: "handle", label: "Handle" },
+      { value: "leva", label: "Leva" },
+      { value: "postprocessing", label: "Postprocessing" },
+      { value: "rapier", label: "Rapier" },
+      { value: "xr", label: "XR" },
+      { value: "uikit", label: "UIKit" },
+      { value: "offscreen", label: "Offscreen" },
+      { value: "zustand", label: "Zustand" },
+      { value: "koota", label: "Koota" },
+      { value: "triplex", label: "Triplex" },
+      { value: "viverse", label: "Viverse" }
+    ],
+    initialValues: ["drei"],
+    required: false
+  });
+  if (p.isCancel(selected)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+async function promptForCustomization(template, name, projectType, integrations, inheritedTooling) {
   let libraryBundler;
   if (projectType === "library") {
     const bundler = await p.select({
@@ -240,31 +297,39 @@ async function promptForCustomization(template, name, projectType) {
     }
     pnpmManageVersions = managePnpm;
   }
-  const linter = await p.select({
-    message: "Linter",
-    options: [
-      { value: "oxlint", label: "Oxlint", hint: "fast, from OXC" },
-      { value: "eslint", label: "ESLint", hint: "classic" },
-      { value: "biome", label: "Biome", hint: "all-in-one" }
-    ],
-    initialValue: "oxlint"
-  });
-  if (p.isCancel(linter)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
+  let linter = inheritedTooling?.linter ?? "oxlint";
+  let formatter = inheritedTooling?.formatter ?? "oxfmt";
+  if (!inheritedTooling?.linter) {
+    const linterChoice = await p.select({
+      message: "Linter",
+      options: [
+        { value: "oxlint", label: "Oxlint", hint: "fast, from OXC" },
+        { value: "eslint", label: "ESLint", hint: "classic" },
+        { value: "biome", label: "Biome", hint: "all-in-one" }
+      ],
+      initialValue: "oxlint"
+    });
+    if (p.isCancel(linterChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    linter = linterChoice;
   }
-  const formatter = await p.select({
-    message: "Formatter",
-    options: [
-      { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
-      { value: "prettier", label: "Prettier", hint: "classic" },
-      { value: "biome", label: "Biome", hint: "all-in-one" }
-    ],
-    initialValue: "oxfmt"
-  });
-  if (p.isCancel(formatter)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
+  if (!inheritedTooling?.formatter) {
+    const formatterChoice = await p.select({
+      message: "Formatter",
+      options: [
+        { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
+        { value: "prettier", label: "Prettier", hint: "classic" },
+        { value: "biome", label: "Biome", hint: "all-in-one" }
+      ],
+      initialValue: "oxfmt"
+    });
+    if (p.isCancel(formatterChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    formatter = formatterChoice;
   }
   const testing = await p.select({
     message: "Testing",
@@ -292,47 +357,7 @@ async function promptForCustomization(template, name, projectType) {
   }
   const baseTemplate = getBaseTemplate(template);
   const finalTemplate = language === "javascript" ? `${baseTemplate}-js` : baseTemplate;
-  let integrations = [];
-  if (baseTemplate === "r3f") {
-    const selected = await p.multiselect({
-      message: "R3F integrations",
-      options: [
-        { value: "drei", label: "Drei" },
-        { value: "handle", label: "Handle" },
-        { value: "leva", label: "Leva" },
-        { value: "postprocessing", label: "Postprocessing" },
-        { value: "rapier", label: "Rapier" },
-        { value: "xr", label: "XR" },
-        { value: "uikit", label: "UIKit" },
-        { value: "offscreen", label: "Offscreen" },
-        { value: "zustand", label: "Zustand" },
-        { value: "koota", label: "Koota" },
-        { value: "triplex", label: "Triplex" },
-        { value: "viverse", label: "Viverse" }
-      ],
-      initialValues: [
-        "drei",
-        "handle",
-        "leva",
-        "postprocessing",
-        "rapier",
-        "xr",
-        "uikit",
-        "offscreen",
-        "zustand",
-        "koota",
-        "triplex",
-        "viverse"
-      ],
-      required: false
-    });
-    if (p.isCancel(selected)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    integrations = selected;
-  }
-  return {
+  const base = {
     name,
     template: finalTemplate,
     projectType,
@@ -342,8 +367,11 @@ async function promptForCustomization(template, name, projectType) {
     pnpmManageVersions,
     linter,
     formatter,
-    testing,
-    ...baseTemplate === "r3f" && {
+    testing
+  };
+  if (baseTemplate === "r3f" && integrations) {
+    return {
+      ...base,
       drei: integrations.includes("drei") ? {} : void 0,
       handle: integrations.includes("handle") ? {} : void 0,
       leva: integrations.includes("leva") ? {} : void 0,
@@ -356,8 +384,9 @@ async function promptForCustomization(template, name, projectType) {
       koota: integrations.includes("koota") ? {} : void 0,
       triplex: integrations.includes("triplex") ? {} : void 0,
       viverse: integrations.includes("viverse") ? {} : void 0
-    }
-  };
+    };
+  }
+  return base;
 }
 async function promptForInitialPackage() {
   const choice = await p.select({
@@ -402,31 +431,14 @@ async function promptForMonorepoCustomization(name) {
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
-  const packageManager = await p.select({
-    message: "Package manager",
-    options: [
-      { value: "pnpm", label: "pnpm" },
-      { value: "npm", label: "npm" },
-      { value: "yarn", label: "yarn" }
-    ],
-    initialValue: "pnpm"
+  const managePnpm = await p.confirm({
+    message: "Enable manage-package-manager-versions?",
+    initialValue: true
   });
-  if (p.isCancel(packageManager)) {
+  if (p.isCancel(managePnpm)) {
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
-  let pnpmManageVersions = true;
-  if (packageManager === "pnpm") {
-    const managePnpm = await p.confirm({
-      message: "Enable manage-package-manager-versions?",
-      initialValue: true
-    });
-    if (p.isCancel(managePnpm)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    pnpmManageVersions = managePnpm;
-  }
   const linter = await p.select({
     message: "Linter",
     options: [
@@ -457,8 +469,8 @@ async function promptForMonorepoCustomization(name) {
     name,
     projectType: "monorepo",
     nodeVersion,
-    packageManager,
-    pnpmManageVersions,
+    packageManager: "pnpm",
+    pnpmManageVersions: managePnpm,
     linter,
     formatter
   };
@@ -476,19 +488,15 @@ async function promptForMonorepo(workspaceName) {
     }),
     "Workspace Configuration"
   );
-  const action = await p.select({
+  const proceed = await p.confirm({
     message: "Proceed with these settings?",
-    options: [
-      { value: "confirm", label: "Yes, create workspace" },
-      { value: "customize", label: "No, let me customize" }
-    ],
-    initialValue: "confirm"
+    initialValue: true
   });
-  if (p.isCancel(action)) {
+  if (p.isCancel(proceed)) {
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
-  if (action === "confirm") {
+  if (proceed) {
     return defaultOptions;
   }
   return promptForMonorepoCustomization(workspaceName);
@@ -528,76 +536,204 @@ async function promptForOptions(name) {
   }
   return promptForPackageOptions(projectName, projectType);
 }
-async function promptForPackageOptions(projectName, projectType) {
-  const template = await p.select({
+function customTemplateToOptions(customTemplate, name, projectType) {
+  const baseTemplate = customTemplate.baseTemplate;
+  const template = baseTemplate;
+  const base = {
+    name,
+    template,
+    projectType,
+    packageManager: "pnpm",
+    pnpmManageVersions: true,
+    nodeVersion: "latest",
+    linter: customTemplate.linter,
+    formatter: customTemplate.formatter,
+    testing: customTemplate.testing
+  };
+  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;
+}
+async function promptForPackageOptions(projectName, projectType, inheritedTooling) {
+  const builtInOptions = [
+    { value: "vanilla", label: "Vanilla" },
+    { value: "react", label: "React" },
+    { value: "r3f", label: "React Three Fiber" }
+  ];
+  const customTemplates = getCustomTemplates();
+  const customOptions = Object.keys(customTemplates).map((name) => ({
+    value: `custom:${name}`,
+    label: name,
+    hint: "saved template"
+  }));
+  const allOptions = [...builtInOptions, ...customOptions];
+  const templateSelection = await p.select({
     message: "Select a template",
-    options: [
-      { value: "vanilla", label: "Vanilla" },
-      { value: "react", label: "React" },
-      { value: "r3f", label: "React Three Fiber" }
-    ],
+    options: allOptions,
     initialValue: "vanilla"
   });
-  if (p.isCancel(template)) {
+  if (p.isCancel(templateSelection)) {
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
+  const selection = templateSelection;
+  if (selection.startsWith("custom:")) {
+    const customName = selection.slice(7);
+    const customTemplate = customTemplates[customName];
+    const defaultOptions2 = customTemplateToOptions(customTemplate, projectName, projectType);
+    if (inheritedTooling?.linter) {
+      defaultOptions2.linter = inheritedTooling.linter;
+    }
+    if (inheritedTooling?.formatter) {
+      defaultOptions2.formatter = inheritedTooling.formatter;
+    }
+    const configTitle2 = inheritedTooling ? `Template: ${customName} (using workspace tooling)` : `Template: ${customName}`;
+    p.note(formatConfigSummary(defaultOptions2), configTitle2);
+    const proceed2 = await p.confirm({
+      message: "Proceed with these settings?",
+      initialValue: true
+    });
+    if (p.isCancel(proceed2)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (proceed2) {
+      return defaultOptions2;
+    }
+    return promptForCustomization(
+      customTemplate.baseTemplate,
+      projectName,
+      projectType,
+      customTemplate.integrations,
+      inheritedTooling
+    );
+  }
+  const template = selection;
+  const baseTemplate = getBaseTemplate(template);
+  let integrations;
+  if (baseTemplate === "r3f") {
+    integrations = await promptForR3fIntegrations();
+  }
   const defaultOptions = getDefaultOptions(
     template,
     projectName,
-    projectType
+    projectType,
+    void 0,
+    integrations,
+    inheritedTooling
   );
-  p.note(formatConfigSummary(defaultOptions), "Template Configuration");
-  const action = await p.select({
+  const configTitle = inheritedTooling ? "Template Configuration (using workspace tooling)" : "Template Configuration";
+  p.note(formatConfigSummary(defaultOptions), configTitle);
+  const proceed = await p.confirm({
     message: "Proceed with these settings?",
-    options: [
-      { value: "confirm", label: "Yes, create project" },
-      { value: "customize", label: "No, let me customize" }
-    ],
-    initialValue: "confirm"
+    initialValue: true
   });
-  if (p.isCancel(action)) {
+  if (p.isCancel(proceed)) {
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
-  if (action === "confirm") {
+  if (proceed) {
     return defaultOptions;
   }
-  return promptForCustomization(
-    template,
-    projectName,
-    projectType
-  );
+  return promptForCustomization(template, projectName, projectType, integrations, inheritedTooling);
 }
 
-const config = new Conf({
-  projectName: "create-krispya"
-});
-function getPreferredEditor() {
-  return config.get("preferredEditor");
-}
-function setPreferredEditor(editor) {
-  config.set("preferredEditor", editor);
-}
-function getReuseWindow() {
-  return config.get("reuseWindow") ?? false;
-}
-function setReuseWindow(reuse) {
-  config.set("reuseWindow", reuse);
+async function checkAnyExists(paths) {
+  for (const path of paths) {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
 }
-function clearConfig() {
-  config.clear();
+async function validateWorkspace(monorepoRoot) {
+  const errors = [];
+  const tsConfigPath = join(monorepoRoot, ".config/typescript/package.json");
+  try {
+    await access(tsConfigPath, constants.F_OK);
+  } catch {
+    errors.push("Missing .config/typescript package");
+  }
+  const linterPaths = [
+    join(monorepoRoot, ".config/oxlint/package.json"),
+    join(monorepoRoot, ".config/eslint/package.json"),
+    join(monorepoRoot, "eslint.config.js"),
+    join(monorepoRoot, "biome.json")
+  ];
+  const hasLinter = await checkAnyExists(linterPaths);
+  if (!hasLinter) {
+    errors.push(
+      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
+    );
+  }
+  const formatterPaths = [
+    join(monorepoRoot, ".config/oxfmt/package.json"),
+    join(monorepoRoot, ".config/prettier/package.json"),
+    join(monorepoRoot, ".prettierrc.json"),
+    join(monorepoRoot, "biome.json")
+  ];
+  const hasFormatter = await checkAnyExists(formatterPaths);
+  if (!hasFormatter) {
+    errors.push(
+      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
+    );
+  }
+  return { valid: errors.length === 0, errors };
 }
 
 const require$1 = createRequire(import.meta.url);
 const pkg = require$1("../package.json");
+async function fileExists(path) {
+  try {
+    await access(path, constants$1.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeGeneratedFiles(basePath, files) {
+  const filePaths = Object.keys(files).sort();
+  for (const filePath of filePaths) {
+    const fullFilePath = join(basePath, filePath);
+    await mkdir(dirname(fullFilePath), { recursive: true });
+    const file = files[filePath];
+    if (file.type === "text") {
+      await writeFile(fullFilePath, file.content);
+    } else {
+      const response = await fetch(file.url);
+      await writeFile(fullFilePath, response.body);
+    }
+  }
+}
+function calculateWorkspaceRoot(packagePath) {
+  const segments = packagePath.split(/[/\\]/).filter(Boolean);
+  return segments.map(() => "..").join("/");
+}
 async function detectMonorepoRoot() {
   let currentDir = cwd();
   const root = resolve("/");
   while (currentDir !== root) {
     const workspaceFile = join(currentDir, "pnpm-workspace.yaml");
     try {
-      await access(workspaceFile, constants.F_OK);
+      await access(workspaceFile, constants$1.F_OK);
       const content = await readFile(workspaceFile, "utf-8");
       if (content.includes("packages:")) {
         return currentDir;
@@ -608,473 +744,1280 @@ async function detectMonorepoRoot() {
   }
   return null;
 }
-async function main() {
-  const program = new Command().name("create-krispya").description("CLI for creating Vanilla, React, and React Three Fiber projects").argument("[name]", "name for the project").option("--type <type>", "project type: app or library (default: app)").option(
-    "--bundler <bundler>",
-    "library bundler: unbuild or tsdown (default: unbuild, only for libraries)"
-  ).option(
-    "--template <type>",
-    "project template: vanilla, vanilla-js, react, react-js, r3f, r3f-js (default: vanilla)"
-  ).option("--linter <type>", "linter: eslint, oxlint, or biome (default: oxlint)").option("--formatter <type>", "formatter: prettier, oxfmt, or biome (default: oxfmt)").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("-y, --yes", "Skip prompts and use default values").option("--clear-config", "Clear saved preferences (e.g. editor choice)").action(async (name, options) => {
-    if (options.clearConfig) {
-      clearConfig();
-      console.log("Configuration cleared.");
-      process.exit(0);
+async function parseWorkspaceDirectories(monorepoRoot) {
+  try {
+    const workspaceFile = join(monorepoRoot, "pnpm-workspace.yaml");
+    const content = await readFile(workspaceFile, "utf-8");
+    return parseWorkspaceYamlContent(content);
+  } catch {
+    return [];
+  }
+}
+async function detectWorkspaceTooling(monorepoRoot) {
+  try {
+    const pkgPath = join(monorepoRoot, "package.json");
+    const content = await readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    const devDeps = pkgJson.devDependencies ?? {};
+    const linter = devDeps.oxlint ? "oxlint" : devDeps.eslint ? "eslint" : devDeps["@biomejs/biome"] ? "biome" : void 0;
+    const formatter = devDeps.oxfmt ? "oxfmt" : devDeps.prettier ? "prettier" : devDeps["@biomejs/biome"] ? "biome" : void 0;
+    return { linter, formatter };
+  } catch {
+    return {};
+  }
+}
+async function detectExistingConfigs(monorepoRoot) {
+  const configs = {};
+  const eslintPath = join(monorepoRoot, "eslint.config.js");
+  if (await fileExists(eslintPath)) {
+    configs.linter = "eslint";
+    configs.eslintConfigPath = eslintPath;
+  }
+  const prettierPath = join(monorepoRoot, ".prettierrc.json");
+  if (await fileExists(prettierPath)) {
+    configs.formatter = "prettier";
+    configs.prettierConfigPath = prettierPath;
+  }
+  const biomePath = join(monorepoRoot, "biome.json");
+  if (await fileExists(biomePath)) {
+    configs.biomeConfigPath = biomePath;
+    if (!configs.linter) configs.linter = "biome";
+    if (!configs.formatter) configs.formatter = "biome";
+  }
+  return configs;
+}
+async function getMonorepoScope(monorepoRoot) {
+  try {
+    const pkgPath = join(monorepoRoot, "package.json");
+    const content = await readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    if (pkgJson.name) {
+      return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
     }
-    console.clear();
-    p.intro(color.bgCyan(color.black(` create-krispya v${pkg.version} `)));
-    const monorepoRoot = await detectMonorepoRoot();
-    if (monorepoRoot && Object.keys(options).length === 0) {
-      const choice = await p.select({
-        message: "Detected monorepo workspace",
-        options: [
-          { value: "add", label: "Add new package to this workspace" },
-          { value: "standalone", label: "Create standalone project" }
-        ],
-        initialValue: "add"
-      });
-      if (p.isCancel(choice)) {
-        p.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (choice === "add") {
-        const packageType = await promptForInitialPackage();
-        if (packageType === "skip") {
-          p.cancel("Operation cancelled.");
-          process.exit(0);
-        }
-        const packageName = await p.text({
-          message: "Package name?",
-          placeholder: packageType === "app" ? "my-app" : "my-package",
-          validate: (value) => {
-            if (!value.length) return "Package name is required";
-          }
-        });
-        if (p.isCancel(packageName)) {
-          p.cancel("Operation cancelled.");
-          process.exit(0);
-        }
-        const targetDir = packageType === "app" ? "apps" : "packages";
-        const packagePath = join(targetDir, packageName);
-        const workspaceRoot = "../..";
-        const packageOptions = await promptForPackageOptions(packageName, packageType);
-        packageOptions.workspaceRoot = workspaceRoot;
-        packageOptions.name = packageName;
-        const packageManager2 = packageOptions.packageManager || "pnpm";
-        if (packageManager2 === "pnpm") {
-          packageOptions.pnpmVersion = await getLatestPnpmVersion();
-        }
-        const nodeVersion2 = packageOptions.nodeVersion ?? "latest";
-        if (nodeVersion2 === "latest") {
-          packageOptions.nodeVersion = await getLatestNodeVersion();
-        }
-        const versions2 = {};
-        const versionPromises2 = [];
-        const pkgIsLibrary = packageOptions.projectType === "library";
-        const pkgTesting = packageOptions.testing ?? (pkgIsLibrary ? "vitest" : "none");
-        if (pkgTesting === "vitest") {
-          versionPromises2.push(
-            getLatestNpmVersion("vitest", "4.0.0").then((v) => {
-              versions2.vitest = v;
-            })
-          );
-        }
-        if (!pkgIsLibrary) {
-          versionPromises2.push(
-            getLatestNpmVersion("vite", "6.3.4").then((v) => {
-              versions2.vite = v;
-            })
-          );
-        }
-        const linter2 = packageOptions.linter ?? "oxlint";
-        if (linter2 === "eslint") {
-          versionPromises2.push(
-            getLatestNpmVersion("eslint", "9.17.0").then((v) => {
-              versions2.eslint = v;
-            })
-          );
-        } else if (linter2 === "oxlint") {
-          versionPromises2.push(
-            getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
-              versions2.oxlint = v;
-            })
-          );
-        } else if (linter2 === "biome") {
-          versionPromises2.push(
-            getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-              versions2.biome = v;
-            })
-          );
-        }
-        const formatter2 = packageOptions.formatter ?? "oxfmt";
-        if (formatter2 === "prettier") {
-          versionPromises2.push(
-            getLatestNpmVersion("prettier", "3.4.2").then((v) => {
-              versions2.prettier = v;
-            })
-          );
-        } else if (formatter2 === "oxfmt") {
-          versionPromises2.push(
-            getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
-              versions2.oxfmt = v;
-            })
-          );
-        } else if (formatter2 === "biome" && linter2 !== "biome") {
-          versionPromises2.push(
-            getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-              versions2.biome = v;
-            })
-          );
-        }
-        await Promise.all(versionPromises2);
-        packageOptions.versions = versions2;
-        const basePath2 = join(monorepoRoot, packagePath);
-        const s2 = p.spinner();
-        s2.start("Creating package...");
+  } catch {
+  }
+  return monorepoRoot.split(/[/\\]/).pop() ?? "workspace";
+}
+async function getWorkspacePackages(monorepoRoot) {
+  const packagesDir = join(monorepoRoot, "packages");
+  const packages = [];
+  try {
+    const { readdir } = await import('fs/promises');
+    const entries = await readdir(packagesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
         try {
-          const files = generate(packageOptions);
-          const filePaths = Object.keys(files).sort();
-          for (const filePath of filePaths) {
-            const fullFilePath = join(basePath2, filePath);
-            await mkdir(dirname(fullFilePath), { recursive: true });
-            const file = files[filePath];
-            if (file.type === "text") {
-              await writeFile(fullFilePath, file.content);
-            } else {
-              const response = await fetch(file.url);
-              await writeFile(fullFilePath, response.body);
-            }
+          const pkgJsonPath = join(packagesDir, entry.name, "package.json");
+          const content = await readFile(pkgJsonPath, "utf-8");
+          const pkgJson = JSON.parse(content);
+          if (pkgJson.name) {
+            packages.push({
+              name: pkgJson.name,
+              path: `packages/${entry.name}`
+            });
           }
-          s2.stop("Package created!");
-          const isLibrary2 = packageOptions.projectType === "library";
-          const nextSteps = isLibrary2 ? [
-            `cd ${packagePath}`,
-            `${packageManager2} install`,
-            `${packageManager2} run build`
-          ].join("\n") : [
-            `cd ${packagePath}`,
-            `${packageManager2} install`,
-            `${packageManager2} run dev`
-          ].join("\n");
-          p.note(nextSteps, "Next steps");
-          p.outro(color.green("Happy coding! \u2728"));
-          process.exit(0);
-        } catch (error) {
-          s2.stop("Failed to create package");
-          p.log.error(String(error));
-          process.exit(1);
+        } catch {
         }
       }
     }
-    let generateOptions;
-    if (Object.keys(options).length > 0) {
-      const template = options.template ?? "vanilla";
-      const baseTemplate = getBaseTemplate(template);
-      const defaultName = getDefaultProjectName(template);
-      const projectType = options.type ?? "app";
-      generateOptions = {
-        name: name || defaultName,
-        projectType,
-        libraryBundler: projectType === "library" ? options.bundler ?? "unbuild" : void 0,
-        template,
-        linter: options.linter ?? "oxlint",
-        formatter: options.formatter ?? "oxfmt",
-        ...baseTemplate === "r3f" && {
-          drei: options.drei ? {} : void 0,
-          handle: options.handle ? {} : void 0,
-          leva: options.leva ? {} : void 0,
-          postprocessing: options.postprocessing ? {} : void 0,
-          rapier: options.rapier ? {} : void 0,
-          xr: options.xr ? {} : void 0,
-          uikit: options.uikit ? {} : void 0,
-          offscreen: options.offscreen ? {} : void 0,
-          zustand: options.zustand ? {} : void 0,
-          koota: options.koota ? {} : void 0,
-          viverse: options.viverse ? {} : void 0,
-          triplex: options.triplex ? {} : void 0
-        },
-        packageManager: options.packageManager,
-        pnpmManageVersions: options.pnpmManageVersions,
-        nodeVersion: options.nodeVersion ?? "latest"
-      };
-    } else {
-      generateOptions = await promptForOptions(name);
-    }
-    if (generateOptions.projectType === "monorepo") {
-      const { generateMonorepo } = await import('./chunks/index.mjs').then(function (n) { return n.m; });
-      const packageManager2 = generateOptions.packageManager || "pnpm";
-      if (packageManager2 === "pnpm") {
-        generateOptions.pnpmVersion = await getLatestPnpmVersion();
+  } catch {
+  }
+  return packages;
+}
+async function ensureConfigInWorkspace(monorepoRoot) {
+  const workspacePath = join(monorepoRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile(workspacePath, "utf-8");
+  } catch {
+    content = `packages:
+  - ".config/*"
+  - "packages/*"
+`;
+    await writeFile(workspacePath, content);
+    return;
+  }
+  if (content.includes(".config/*") || content.includes('".config/*"')) {
+    return;
+  }
+  const lines = content.split("\n");
+  const packagesIndex = lines.findIndex(
+    (line) => line.trim().startsWith("packages:")
+  );
+  if (packagesIndex === -1) {
+    content = `packages:
+  - ".config/*"
+${content}`;
+  } else {
+    lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
+    content = lines.join("\n");
+  }
+  await writeFile(workspacePath, content);
+}
+async function migrateEslintConfig(monorepoRoot, files) {
+  const configBasePath = ".config/eslint";
+  const existingConfigPath = join(monorepoRoot, "eslint.config.js");
+  let existingContent;
+  try {
+    existingContent = await readFile(existingConfigPath, "utf-8");
+  } catch {
+    generateEslintConfigPackage(files);
+    return;
+  }
+  files[`${configBasePath}/package.json`] = {
+    type: "text",
+    content: JSON.stringify(
+      {
+        name: "@config/eslint",
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        exports: {
+          "./base": "./base.js",
+          "./react": "./react.js"
+        }
+      },
+      null,
+      2
+    )
+  };
+  files[`${configBasePath}/README.md`] = {
+    type: "text",
+    content: `# \`@config/eslint\`
+
+Shared ESLint configurations.
+
+## Usage
+
+In your package's \`eslint.config.js\`:
+
+\`\`\`js
+import base from "@config/eslint/base";
+
+export default [...base];
+\`\`\`
+
+## Available Configs
+
+- \`base\` - Base ESLint rules (migrated from root)
+- \`react\` - React-specific rules
+`
+  };
+  files[`${configBasePath}/base.js`] = {
+    type: "text",
+    content: existingContent
+  };
+  files[`${configBasePath}/react.js`] = {
+    type: "text",
+    content: `import react from "eslint-plugin-react";
+import reactHooks from "eslint-plugin-react-hooks";
+
+export default [
+  {
+    plugins: {
+      react,
+      "react-hooks": reactHooks,
+    },
+    rules: {
+      ...react.configs.recommended.rules,
+      ...reactHooks.configs.recommended.rules,
+      "react/react-in-jsx-scope": "off",
+    },
+    settings: {
+      react: {
+        version: "detect",
+      },
+    },
+  },
+];
+`
+  };
+}
+async function migratePrettierConfig(monorepoRoot, files) {
+  const configBasePath = ".config/prettier";
+  const existingConfigPath = join(monorepoRoot, ".prettierrc.json");
+  let existingContent;
+  try {
+    existingContent = await readFile(existingConfigPath, "utf-8");
+  } catch {
+    generatePrettierConfigPackage(files);
+    return;
+  }
+  files[`${configBasePath}/package.json`] = {
+    type: "text",
+    content: JSON.stringify(
+      {
+        name: "@config/prettier",
+        version: "0.1.0",
+        private: true,
+        exports: {
+          "./base": "./base.json"
+        }
+      },
+      null,
+      2
+    )
+  };
+  files[`${configBasePath}/README.md`] = {
+    type: "text",
+    content: `# \`@config/prettier\`
+
+Shared Prettier configurations.
+
+## Usage
+
+In your package's \`.prettierrc\`:
+
+\`\`\`json
+"@config/prettier/base"
+\`\`\`
+
+Or in \`package.json\`:
+
+\`\`\`json
+{
+  "prettier": "@config/prettier/base"
+}
+\`\`\`
+
+## Available Configs
+
+- \`base\` - Base Prettier rules (migrated from root)
+`
+  };
+  files[`${configBasePath}/base.json`] = {
+    type: "text",
+    content: existingContent
+  };
+}
+async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedTooling, scope) {
+  const workspaceDirectories = await parseWorkspaceDirectories(monorepoRoot);
+  const defaultDirectories = ["apps", "packages"];
+  const hasCustomDirectories = workspaceDirectories.length > 0 && !workspaceDirectories.every((dir) => defaultDirectories.includes(dir));
+  const packageType = await promptForInitialPackage();
+  if (packageType === "skip") {
+    return false;
+  }
+  const defaultDir = packageType === "app" ? "apps" : "packages";
+  const packageNameInput = await p.text({
+    message: "Package name?",
+    initialValue: `@${scope}/`,
+    validate: (value) => {
+      const validationError = validatePackageName(value);
+      if (validationError) return validationError;
+      const dirName = value.includes("/") ? value.split("/").pop() : value;
+      if (!dirName) return "Package name is required";
+      if (!hasCustomDirectories) {
+        const targetPath = join(monorepoRoot, defaultDir, dirName);
+        try {
+          const { statSync } = require$1("fs");
+          statSync(targetPath);
+          return `Directory ${defaultDir}/${dirName} already exists`;
+        } catch {
+        }
       }
-      const nodeVersion2 = generateOptions.nodeVersion ?? "latest";
-      if (nodeVersion2 === "latest") {
-        generateOptions.nodeVersion = await getLatestNodeVersion();
+    }
+  });
+  if (p.isCancel(packageNameInput)) {
+    return false;
+  }
+  const scopedName = packageNameInput;
+  const shortName = scopedName.includes("/") ? scopedName.split("/").pop() : scopedName;
+  const packageOptions = await promptForPackageOptions(
+    scopedName,
+    packageType,
+    inheritedTooling
+  );
+  let targetDir = defaultDir;
+  if (hasCustomDirectories && workspaceDirectories.length > 0) {
+    const dirChoice = await p.select({
+      message: "Target directory",
+      options: workspaceDirectories.map((dir) => ({
+        value: dir,
+        label: dir
+      })),
+      initialValue: workspaceDirectories.includes(defaultDir) ? defaultDir : workspaceDirectories[0]
+    });
+    if (p.isCancel(dirChoice)) {
+      return false;
+    }
+    targetDir = dirChoice;
+    const targetPath = join(monorepoRoot, targetDir, shortName);
+    try {
+      const { statSync } = require$1("fs");
+      statSync(targetPath);
+      p.log.error(`Directory ${targetDir}/${shortName} already exists`);
+      return false;
+    } catch {
+    }
+  }
+  const relativePkgPath = join(targetDir, shortName);
+  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
+  packageOptions.workspaceRoot = workspaceRoot;
+  packageOptions.name = scopedName;
+  if (packageManager === "pnpm") {
+    packageOptions.pnpmVersion = await getLatestPnpmVersion();
+  } else if (packageManager === "yarn") {
+    packageOptions.yarnVersion = await getLatestYarnVersion();
+  } else if (packageManager === "npm") {
+    packageOptions.npmVersion = await getLatestNpmCliVersion();
+  }
+  const nodeVersion = packageOptions.nodeVersion ?? "latest";
+  if (nodeVersion === "latest") {
+    packageOptions.nodeVersion = await getLatestNodeVersion();
+  }
+  const versions = {};
+  const versionPromises = [];
+  const pkgIsLibrary = packageOptions.projectType === "library";
+  const pkgTesting = packageOptions.testing ?? (pkgIsLibrary ? "vitest" : "none");
+  if (pkgTesting === "vitest") {
+    versionPromises.push(
+      getLatestNpmVersion("vitest", "4.0.0").then((v) => {
+        versions.vitest = v;
+      })
+    );
+  }
+  if (!pkgIsLibrary) {
+    versionPromises.push(
+      getLatestNpmVersion("vite", "6.3.4").then((v) => {
+        versions.vite = v;
+      })
+    );
+  }
+  const linter = packageOptions.linter ?? "oxlint";
+  if (linter === "eslint") {
+    versionPromises.push(
+      getLatestNpmVersion("eslint", "9.17.0").then((v) => {
+        versions.eslint = v;
+      })
+    );
+  } else if (linter === "oxlint") {
+    versionPromises.push(
+      getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
+        versions.oxlint = v;
+      })
+    );
+  } else if (linter === "biome") {
+    versionPromises.push(
+      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
+        versions.biome = v;
+      })
+    );
+  }
+  const formatter = packageOptions.formatter ?? "oxfmt";
+  if (formatter === "prettier") {
+    versionPromises.push(
+      getLatestNpmVersion("prettier", "3.4.2").then((v) => {
+        versions.prettier = v;
+      })
+    );
+  } else if (formatter === "oxfmt") {
+    versionPromises.push(
+      getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
+        versions.oxfmt = v;
+      })
+    );
+  } else if (formatter === "biome" && linter !== "biome") {
+    versionPromises.push(
+      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
+        versions.biome = v;
+      })
+    );
+  }
+  await Promise.all(versionPromises);
+  packageOptions.versions = versions;
+  if (packageType === "app") {
+    const workspacePackages = await getWorkspacePackages(monorepoRoot);
+    if (workspacePackages.length > 0) {
+      const selectedDeps = await p.multiselect({
+        message: "Add workspace dependencies?",
+        options: workspacePackages.map((pkgInfo) => ({
+          value: pkgInfo.name,
+          label: pkgInfo.name.replace(/^@[^/]+\//, "")
+        })),
+        required: false
+      });
+      if (!p.isCancel(selectedDeps) && selectedDeps.length > 0) {
+        packageOptions.workspaceDependencies = selectedDeps;
       }
-      const basePath2 = join(cwd(), generateOptions.name);
-      const s2 = p.spinner();
-      s2.start("Creating monorepo workspace...");
-      try {
-        const { files } = generateMonorepo({
-          name: generateOptions.name,
-          linter: generateOptions.linter ?? "oxlint",
-          formatter: generateOptions.formatter ?? "oxfmt",
-          packageManager: packageManager2,
-          pnpmVersion: generateOptions.pnpmVersion,
-          pnpmManageVersions: generateOptions.pnpmManageVersions,
-          nodeVersion: generateOptions.nodeVersion
-        });
-        const filePaths = Object.keys(files).sort();
-        for (const filePath of filePaths) {
-          const fullFilePath = join(basePath2, filePath);
-          await mkdir(dirname(fullFilePath), { recursive: true });
-          const file = files[filePath];
-          if (file.type === "text") {
-            await writeFile(fullFilePath, file.content);
-          }
-        }
-        s2.stop("Monorepo workspace created!");
-        const initialPackage = await promptForInitialPackage();
-        if (initialPackage !== "skip") {
-          const packageName = await p.text({
-            message: "Package name?",
-            placeholder: initialPackage === "app" ? "my-app" : "my-package",
-            validate: (value) => {
-              if (!value.length) return "Package name is required";
-            }
+    }
+  }
+  const outputPath = join(monorepoRoot, relativePkgPath);
+  const spinner = p.spinner();
+  spinner.start("Creating package...");
+  try {
+    const files = generate(packageOptions);
+    await writeGeneratedFiles(outputPath, files);
+    spinner.stop(
+      color.green.inverse(` \u2713 Package created at ${relativePkgPath}! `)
+    );
+    const addAnother = await p.select({
+      message: "Add another package?",
+      options: [
+        { value: "no", label: "No, I'm done" },
+        { value: "yes", label: "Yes, add another" }
+      ],
+      initialValue: "no"
+    });
+    return !p.isCancel(addAnother) && addAnother === "yes";
+  } catch (error) {
+    spinner.stop("Failed to create package");
+    p.log.error(String(error));
+    return false;
+  }
+}
+async function promptAndOpenEditor(projectPath) {
+  const savedEditor = getPreferredEditor();
+  let selectedEditor;
+  if (savedEditor && savedEditor !== "skip") {
+    const useDefault = await p.confirm({
+      message: `Open in editor? ${color.dim(`(${editorNames[savedEditor]})`)}`,
+      initialValue: true
+    });
+    if (p.isCancel(useDefault)) {
+      selectedEditor = void 0;
+    } else if (useDefault) {
+      selectedEditor = savedEditor;
+    } else {
+      selectedEditor = "skip";
+    }
+  } else {
+    const openEditor = await p.select({
+      message: "Open project in editor?",
+      options: [
+        { value: "skip", label: "Skip" },
+        { value: "cursor", label: "Cursor" },
+        { value: "code", label: "VS Code" },
+        { value: "webstorm", label: "WebStorm" }
+      ],
+      initialValue: "skip"
+    });
+    if (!p.isCancel(openEditor)) {
+      selectedEditor = openEditor;
+      const saveChoice = await p.confirm({
+        message: `Save ${editorNames[selectedEditor] ?? "Skip"} as default editor?`,
+        initialValue: true
+      });
+      if (!p.isCancel(saveChoice) && saveChoice) {
+        setPreferredEditor(selectedEditor);
+        if (selectedEditor === "cursor" || selectedEditor === "code") {
+          const reuseChoice = await p.confirm({
+            message: "Reuse current window when opening projects?",
+            initialValue: false
           });
-          if (!p.isCancel(packageName)) {
-            const targetDir = initialPackage === "app" ? "apps" : "packages";
-            const packagePath = join(targetDir, packageName);
-            const packageOptions = await promptForPackageOptions(packageName, initialPackage);
-            packageOptions.workspaceRoot = "../..";
-            packageOptions.name = packageName;
-            const pkgManager = packageOptions.packageManager || "pnpm";
-            const versions2 = {};
-            const versionPromises2 = [];
-            const initPkgIsLibrary = packageOptions.projectType === "library";
-            const initPkgTesting = packageOptions.testing ?? (initPkgIsLibrary ? "vitest" : "none");
-            if (initPkgTesting === "vitest") {
-              versionPromises2.push(
-                getLatestNpmVersion("vitest", "4.0.0").then((v) => {
-                  versions2.vitest = v;
-                })
-              );
-            }
-            if (!initPkgIsLibrary) {
-              versionPromises2.push(
-                getLatestNpmVersion("vite", "6.3.4").then((v) => {
-                  versions2.vite = v;
-                })
-              );
-            }
-            await Promise.all(versionPromises2);
-            packageOptions.versions = versions2;
-            s2.start("Creating initial package...");
-            const packageFiles = generate(packageOptions);
-            const packageFilePaths = Object.keys(packageFiles).sort();
-            const packageBasePath = join(basePath2, packagePath);
-            for (const filePath of packageFilePaths) {
-              const fullFilePath = join(packageBasePath, filePath);
-              await mkdir(dirname(fullFilePath), { recursive: true });
-              const file = packageFiles[filePath];
-              if (file.type === "text") {
-                await writeFile(fullFilePath, file.content);
-              } else {
-                const response = await fetch(file.url);
-                await writeFile(fullFilePath, response.body);
-              }
-            }
-            s2.stop("Initial package created!");
+          if (!p.isCancel(reuseChoice)) {
+            setReuseWindow(reuseChoice);
           }
         }
-        const nextSteps = [
-          `cd ${generateOptions.name}`,
-          `${packageManager2} install`,
-          `${packageManager2} run dev`
-        ].join("\n");
-        p.note(nextSteps, "Next steps");
-        p.outro(color.green("Happy coding! \u2728"));
-        process.exit(0);
-      } catch (error) {
-        s2.stop("Failed to create monorepo workspace");
-        p.log.error(String(error));
-        process.exit(1);
       }
     }
-    const base = generateOptions.template ? getBaseTemplate(generateOptions.template) : "vanilla";
-    const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
-    generateOptions.name ??= defaultFallbackName;
-    const packageManager = generateOptions.packageManager || "pnpm";
-    if (packageManager === "pnpm") {
-      generateOptions.pnpmVersion = await getLatestPnpmVersion();
+  }
+  if (selectedEditor && selectedEditor !== "skip") {
+    try {
+      await openInEditor(
+        selectedEditor,
+        projectPath,
+        getReuseWindow()
+      );
+      p.log.success(`Opening in ${editorNames[selectedEditor]}...`);
+    } catch {
+      p.log.warn(
+        `Could not open ${editorNames[selectedEditor]}. Make sure the CLI command is in your PATH.`
+      );
     }
-    const nodeVersion = generateOptions.nodeVersion ?? "latest";
-    if (nodeVersion === "latest") {
-      generateOptions.nodeVersion = await getLatestNodeVersion();
+  }
+}
+async function handleCheckCommand() {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color.red("\u2717") + " Not a monorepo workspace");
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color.green("\u2713") + " Valid monorepo workspace");
+    console.log(color.dim(`  ${monorepoRoot}`));
+  } else {
+    console.log(color.red("\u2717") + " Invalid monorepo workspace");
+    console.log(color.dim(`  ${monorepoRoot}`));
+    for (const error of errors) {
+      console.log(color.red(`  \u2022 ${error}`));
     }
-    const versions = {};
-    const versionPromises = [];
-    const isLibrary = generateOptions.projectType === "library";
-    const testing = generateOptions.testing ?? (isLibrary ? "vitest" : "none");
-    if (testing === "vitest") {
-      versionPromises.push(
-        getLatestNpmVersion("vitest", "4.0.0").then((v) => {
-          versions.vitest = v;
-        })
-      );
+  }
+  process.exit(valid ? 0 : 1);
+}
+async function handleFixCommand(options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color.red("\u2717") + " Not a monorepo workspace");
+    console.log(color.dim("  Run this command from within a monorepo"));
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color.green("\u2713") + " Workspace is already valid");
+    console.log(color.dim(`  ${monorepoRoot}`));
+    process.exit(0);
+  }
+  console.log(color.yellow("!") + " Invalid monorepo workspace");
+  for (const error of errors) {
+    console.log(color.dim(`  \u2022 ${error}`));
+  }
+  console.log();
+  const tooling = await detectWorkspaceTooling(monorepoRoot);
+  const existingConfigs = await detectExistingConfigs(monorepoRoot);
+  const detectedLinter = tooling.linter ?? existingConfigs.linter ?? "oxlint";
+  const detectedFormatter = tooling.formatter ?? existingConfigs.formatter ?? "oxfmt";
+  const isNonInteractive = options.linter && options.formatter;
+  let linter;
+  let formatter;
+  if (isNonInteractive) {
+    linter = options.linter;
+    formatter = options.formatter;
+  } else {
+    const linterChoice = await p.select({
+      message: "Linter",
+      options: [
+        {
+          value: "oxlint",
+          label: "oxlint" + (tooling.linter === "oxlint" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "eslint",
+          label: "eslint" + (tooling.linter === "eslint" || existingConfigs.linter === "eslint" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "biome",
+          label: "biome" + (tooling.linter === "biome" ? color.dim(" (installed)") : "")
+        }
+      ],
+      initialValue: detectedLinter
+    });
+    if (p.isCancel(linterChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
     }
-    if (!isLibrary) {
-      versionPromises.push(
-        getLatestNpmVersion("vite", "6.3.4").then((v) => {
-          versions.vite = v;
-        })
-      );
+    const formatterChoice = await p.select({
+      message: "Formatter",
+      options: [
+        {
+          value: "oxfmt",
+          label: "oxfmt" + (tooling.formatter === "oxfmt" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "prettier",
+          label: "prettier" + (tooling.formatter === "prettier" || existingConfigs.formatter === "prettier" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "biome",
+          label: "biome" + (tooling.formatter === "biome" ? color.dim(" (installed)") : "")
+        }
+      ],
+      initialValue: detectedFormatter
+    });
+    if (p.isCancel(formatterChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
     }
-    const linter = generateOptions.linter ?? "oxlint";
-    if (linter === "eslint") {
-      versionPromises.push(
-        getLatestNpmVersion("eslint", "9.17.0").then((v) => {
-          versions.eslint = v;
-        })
-      );
-    } else if (linter === "oxlint") {
-      versionPromises.push(
-        getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
-          versions.oxlint = v;
-        })
+    linter = linterChoice;
+    formatter = formatterChoice;
+  }
+  console.log();
+  const spinner = p.spinner();
+  spinner.start("Fixing workspace...");
+  try {
+    const files = {};
+    const tsConfigExists = await fileExists(
+      join(monorepoRoot, ".config/typescript/package.json")
+    );
+    if (!tsConfigExists) {
+      generateTypescriptConfigPackage(files);
+    }
+    if (linter === "oxlint") {
+      const oxlintExists = await fileExists(
+        join(monorepoRoot, ".config/oxlint/package.json")
       );
-    } else if (linter === "biome") {
-      versionPromises.push(
-        getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-          versions.biome = v;
-        })
+      if (!oxlintExists) generateOxlintConfigPackage(files);
+    } else if (linter === "eslint") {
+      const eslintPkgExists = await fileExists(
+        join(monorepoRoot, ".config/eslint/package.json")
       );
+      if (!eslintPkgExists) {
+        if (existingConfigs.eslintConfigPath) {
+          await migrateEslintConfig(monorepoRoot, files);
+        } else {
+          generateEslintConfigPackage(files);
+        }
+      }
     }
-    const formatter = generateOptions.formatter ?? "oxfmt";
-    if (formatter === "prettier") {
-      versionPromises.push(
-        getLatestNpmVersion("prettier", "3.4.2").then((v) => {
-          versions.prettier = v;
-        })
-      );
-    } else if (formatter === "oxfmt") {
-      versionPromises.push(
-        getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
-          versions.oxfmt = v;
-        })
+    if (formatter === "oxfmt") {
+      const oxfmtExists = await fileExists(
+        join(monorepoRoot, ".config/oxfmt/package.json")
       );
-    } else if (formatter === "biome" && linter !== "biome") {
-      versionPromises.push(
-        getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
-          versions.biome = v;
-        })
+      if (!oxfmtExists) generateOxfmtConfigPackage(files);
+    } else if (formatter === "prettier") {
+      const prettierPkgExists = await fileExists(
+        join(monorepoRoot, ".config/prettier/package.json")
       );
-    }
-    await Promise.all(versionPromises);
-    generateOptions.versions = versions;
-    const basePath = join(cwd(), generateOptions.name);
-    const s = p.spinner();
-    s.start("Creating project...");
-    try {
-      const files = generate(generateOptions);
-      const filePaths = Object.keys(files).sort();
-      for (const filePath of filePaths) {
-        const fullFilePath = join(basePath, filePath);
-        await mkdir(dirname(fullFilePath), { recursive: true });
-        const file = files[filePath];
-        if (file.type === "text") {
-          await writeFile(fullFilePath, file.content);
+      if (!prettierPkgExists) {
+        if (existingConfigs.prettierConfigPath) {
+          await migratePrettierConfig(monorepoRoot, files);
         } else {
-          const response = await fetch(file.url);
-          await writeFile(fullFilePath, response.body);
+          generatePrettierConfigPackage(files);
+        }
+      }
+    }
+    if ((linter === "biome" || formatter === "biome") && !existingConfigs.biomeConfigPath) {
+      const biomeConfig = {
+        $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+        vcs: {
+          enabled: true,
+          clientKind: "git",
+          useIgnoreFile: true
+        },
+        linter: {
+          enabled: linter === "biome",
+          rules: {
+            recommended: true
+          }
+        },
+        formatter: {
+          enabled: formatter === "biome"
+        }
+      };
+      files["biome.json"] = {
+        type: "text",
+        content: JSON.stringify(biomeConfig, null, 2)
+      };
+    }
+    for (const [filePath, file] of Object.entries(files)) {
+      const fullPath = join(monorepoRoot, filePath);
+      await mkdir(dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, file.content);
+    }
+    await ensureConfigInWorkspace(monorepoRoot);
+    if (existingConfigs.eslintConfigPath && linter === "eslint") {
+      try {
+        await unlink(existingConfigs.eslintConfigPath);
+      } catch {
+      }
+    }
+    if (existingConfigs.prettierConfigPath && formatter === "prettier") {
+      try {
+        await unlink(existingConfigs.prettierConfigPath);
+      } catch {
+      }
+    }
+    spinner.stop(color.green("\u2713") + " Workspace fixed!");
+    const generated = Object.keys(files).filter(
+      (f) => f.endsWith("package.json")
+    );
+    for (const pkgFile of generated) {
+      const pkgName = pkgFile.replace("/package.json", "");
+      console.log(color.dim(`  Generated ${pkgName}`));
+    }
+    const vscodeSettingsExists = await fileExists(
+      join(monorepoRoot, ".vscode/settings.json")
+    );
+    const vscodeExtensionsExists = await fileExists(
+      join(monorepoRoot, ".vscode/extensions.json")
+    );
+    const vscodeExists = vscodeSettingsExists && vscodeExtensionsExists;
+    if (!vscodeExists) {
+      let addVscode = false;
+      if (isNonInteractive) {
+        addVscode = true;
+      } else {
+        const vscodeChoice = await p.confirm({
+          message: "Generate VS Code settings?",
+          initialValue: true
+        });
+        addVscode = !p.isCancel(vscodeChoice) && vscodeChoice;
+      }
+      if (addVscode) {
+        const vscodeFiles = {};
+        generateVscodeFiles(vscodeFiles, linter, formatter);
+        for (const [filePath, file] of Object.entries(vscodeFiles)) {
+          const fullPath = join(monorepoRoot, filePath);
+          await mkdir(dirname(fullPath), { recursive: true });
+          await writeFile(fullPath, file.content);
         }
+        console.log(color.dim("  Generated .vscode/settings.json"));
+        console.log(color.dim("  Generated .vscode/extensions.json"));
       }
-      s.stop("Project created!");
-      const isLibrary2 = generateOptions.projectType === "library";
-      const nextSteps = isLibrary2 ? [
-        `cd ${generateOptions.name}`,
-        `${packageManager} install`,
-        `${packageManager} run build`
-      ].join("\n") : [
-        `cd ${generateOptions.name}`,
-        `${packageManager} install`,
-        `${packageManager} run dev`
-      ].join("\n");
-      p.note(nextSteps, "Next steps");
-      const savedEditor = getPreferredEditor();
-      let selectedEditor;
-      if (savedEditor && savedEditor !== "skip") {
+    }
+    const aiFilePaths = {
+      "cursor-rules": ".cursor/rules",
+      "agents-md": "AGENTS.md",
+      "claude-md": "CLAUDE.md",
+      "copilot-md": ".github/copilot-instructions.md"
+    };
+    const existingAiFiles = [];
+    for (const [choice, path] of Object.entries(aiFilePaths)) {
+      if (await fileExists(join(monorepoRoot, path))) {
+        existingAiFiles.push(choice);
+      }
+    }
+    let selectedAiFiles = [];
+    const savedAiFiles = getAiFiles();
+    const availableChoices = ["cursor-rules", "agents-md", "claude-md", "copilot-md"].filter((c) => !existingAiFiles.includes(c));
+    if (availableChoices.length === 0) {
+    } else if (isNonInteractive) {
+      const preferred = savedAiFiles ?? ["cursor-rules"];
+      selectedAiFiles = preferred.filter((f) => availableChoices.includes(f));
+    } else if (savedAiFiles && savedAiFiles.length > 0) {
+      const availableSaved = savedAiFiles.filter(
+        (f) => availableChoices.includes(f)
+      );
+      if (availableSaved.length > 0) {
+        const savedLabels = availableSaved.map((f) => aiFilePaths[f]).join(", ");
         const useDefault = await p.confirm({
-          message: `Open in editor? ${color.dim(`(${editorNames[savedEditor]})`)}`,
+          message: `Generate AI instruction files? ${color.dim(
+            `(${savedLabels})`
+          )}`,
           initialValue: true
         });
-        if (p.isCancel(useDefault)) {
-          selectedEditor = void 0;
-        } else if (useDefault) {
-          selectedEditor = savedEditor;
-        } else {
-          selectedEditor = "skip";
+        if (!p.isCancel(useDefault) && useDefault) {
+          selectedAiFiles = availableSaved;
         }
-      } else {
-        const openEditor = await p.select({
-          message: "Open project in editor?",
-          options: [
-            { value: "skip", label: "Skip" },
-            { value: "cursor", label: "Cursor" },
-            { value: "code", label: "VS Code" },
-            { value: "webstorm", label: "WebStorm" }
-          ],
-          initialValue: "skip"
+      }
+    } else {
+      const aiFilesChoice = await p.multiselect({
+        message: "Generate AI instruction files?",
+        options: availableChoices.map((c) => ({
+          value: c,
+          label: aiFilePaths[c],
+          hint: c === "cursor-rules" ? "Cursor AI" : c === "agents-md" ? "GitHub Copilot, general" : c === "claude-md" ? "Claude" : "GitHub Copilot"
+        })),
+        required: false
+      });
+      if (!p.isCancel(aiFilesChoice) && aiFilesChoice.length > 0) {
+        selectedAiFiles = aiFilesChoice;
+        const saveChoice = await p.confirm({
+          message: "Save as default for future?",
+          initialValue: true
         });
-        if (!p.isCancel(openEditor)) {
-          selectedEditor = openEditor;
-          const saveChoice = await p.confirm({
-            message: `Save ${editorNames[selectedEditor] ?? "Skip"} as default editor?`,
-            initialValue: true
-          });
-          if (!p.isCancel(saveChoice) && saveChoice) {
-            setPreferredEditor(selectedEditor);
-            if (selectedEditor === "cursor" || selectedEditor === "code") {
-              const reuseChoice = await p.confirm({
-                message: "Reuse current window when opening projects?",
-                initialValue: false
-              });
-              if (!p.isCancel(reuseChoice)) {
-                setReuseWindow(reuseChoice);
-              }
-            }
-          }
+        if (!p.isCancel(saveChoice) && saveChoice) {
+          setAiFiles(selectedAiFiles);
         }
       }
-      if (selectedEditor && selectedEditor !== "skip") {
-        try {
-          await openInEditor(
-            selectedEditor,
-            basePath,
-            getReuseWindow()
-          );
-          p.log.success(`Opening in ${editorNames[selectedEditor]}...`);
-        } catch {
-          p.log.warn(
-            `Could not open ${editorNames[selectedEditor]}. Make sure the CLI command is in your PATH.`
-          );
+    }
+    if (selectedAiFiles.length > 0) {
+      const scope = await getMonorepoScope(monorepoRoot);
+      const aiFilesOutput = {};
+      generateAiFiles(aiFilesOutput, {
+        name: scope,
+        packageManager: "pnpm",
+        linter,
+        formatter,
+        aiFiles: selectedAiFiles
+      });
+      for (const [filePath, file] of Object.entries(aiFilesOutput)) {
+        const fullPath = join(monorepoRoot, filePath);
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, file.content);
+        console.log(color.dim(`  Generated ${filePath}`));
+      }
+    }
+    process.exit(0);
+  } catch (error) {
+    spinner.stop(color.red("\u2717") + " Failed to fix workspace");
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function handleWorkspaceCommand(name, options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.error(
+      color.red("Error:") + " --workspace flag requires being inside a monorepo"
+    );
+    process.exit(1);
+  }
+  if (!name) {
+    console.error(
+      color.red("Error:") + " Package name is required with --workspace flag"
+    );
+    console.log(
+      color.dim(
+        "  Example: pnpm create krispya my-lib --workspace --type library"
+      )
+    );
+    process.exit(1);
+  }
+  const scope = await getMonorepoScope(monorepoRoot);
+  const inheritedTooling = await detectWorkspaceTooling(monorepoRoot);
+  const projectType = options.type ?? "app";
+  const defaultDir = projectType === "library" ? "packages" : "apps";
+  const targetDir = options.dir ?? defaultDir;
+  const template = options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const scopedName = name.startsWith("@") ? name : `@${scope}/${name}`;
+  const fullPackagePath = join(monorepoRoot, targetDir, name);
+  try {
+    await access(fullPackagePath, constants$1.F_OK);
+    console.error(
+      color.red("Error:") + ` Directory ${targetDir}/${name} already exists`
+    );
+    process.exit(1);
+  } catch {
+  }
+  const versions = {};
+  const versionPromises = [];
+  const isLibrary = projectType === "library";
+  if (!isLibrary) {
+    versionPromises.push(
+      getLatestNpmVersion("vite", "6.3.4").then((v) => {
+        versions.vite = v;
+      })
+    );
+  }
+  const linter = inheritedTooling.linter ?? options.linter ?? "oxlint";
+  const formatter = inheritedTooling.formatter ?? options.formatter ?? "oxfmt";
+  await Promise.all(versionPromises);
+  const relativePkgPath = join(targetDir, name);
+  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
+  const generateOptions = {
+    name: scopedName,
+    projectType,
+    libraryBundler: isLibrary ? options.bundler ?? "unbuild" : void 0,
+    template,
+    linter,
+    formatter,
+    workspaceRoot,
+    versions,
+    ...baseTemplate === "r3f" && {
+      drei: options.drei ? {} : void 0,
+      handle: options.handle ? {} : void 0,
+      leva: options.leva ? {} : void 0,
+      postprocessing: options.postprocessing ? {} : void 0,
+      rapier: options.rapier ? {} : void 0,
+      xr: options.xr ? {} : void 0,
+      uikit: options.uikit ? {} : void 0,
+      offscreen: options.offscreen ? {} : void 0,
+      zustand: options.zustand ? {} : void 0,
+      koota: options.koota ? {} : void 0,
+      viverse: options.viverse ? {} : void 0,
+      triplex: options.triplex ? {} : void 0
+    }
+  };
+  console.log(
+    color.cyan("Creating") + ` ${scopedName} in ${targetDir}/${name}...`
+  );
+  try {
+    const files = generate(generateOptions);
+    await writeGeneratedFiles(fullPackagePath, files);
+    console.log(
+      color.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${name}`
+    );
+    process.exit(0);
+  } catch (error) {
+    console.error(color.red("Error:") + " Failed to create package");
+    console.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleMonorepoCreation(generateOptions) {
+  const { generateMonorepo } = await import('./chunks/index.mjs').then(function (n) { return n.s; });
+  const packageManager = generateOptions.packageManager || "pnpm";
+  if (packageManager === "pnpm") {
+    generateOptions.pnpmVersion = await getLatestPnpmVersion();
+  } else if (packageManager === "yarn") {
+    generateOptions.yarnVersion = await getLatestYarnVersion();
+  } else if (packageManager === "npm") {
+    generateOptions.npmVersion = await getLatestNpmCliVersion();
+  }
+  const nodeVersion = generateOptions.nodeVersion ?? "latest";
+  if (nodeVersion === "latest") {
+    generateOptions.nodeVersion = await getLatestNodeVersion();
+  }
+  const savedAiFiles = getAiFiles();
+  let selectedAiFiles = [];
+  if (savedAiFiles && savedAiFiles.length > 0) {
+    const aiFileLabels = {
+      "cursor-rules": ".cursor/rules",
+      "agents-md": "AGENTS.md",
+      "claude-md": "CLAUDE.md",
+      "copilot-md": ".github/copilot-instructions.md"
+    };
+    const savedLabels = savedAiFiles.map((f) => aiFileLabels[f]).join(", ");
+    const useDefault = await p.confirm({
+      message: `Generate AI instruction files? ${color.dim(
+        `(${savedLabels})`
+      )}`,
+      initialValue: true
+    });
+    if (!p.isCancel(useDefault) && useDefault) {
+      selectedAiFiles = savedAiFiles;
+    }
+  } else {
+    const aiFilesChoice = await p.multiselect({
+      message: "Generate AI instruction files?",
+      options: [
+        { value: "cursor-rules", label: ".cursor/rules", hint: "Cursor AI" },
+        {
+          value: "agents-md",
+          label: "AGENTS.md",
+          hint: "GitHub Copilot, general"
+        },
+        { value: "claude-md", label: "CLAUDE.md", hint: "Claude" },
+        {
+          value: "copilot-md",
+          label: ".github/copilot-instructions.md",
+          hint: "GitHub Copilot"
         }
+      ],
+      required: false
+    });
+    if (!p.isCancel(aiFilesChoice) && aiFilesChoice.length > 0) {
+      selectedAiFiles = aiFilesChoice;
+      const saveChoice = await p.confirm({
+        message: "Save as default for future monorepos?",
+        initialValue: true
+      });
+      if (!p.isCancel(saveChoice) && saveChoice) {
+        setAiFiles(selectedAiFiles);
+      }
+    }
+  }
+  const projectPath = join(cwd(), generateOptions.name);
+  const spinner = p.spinner();
+  spinner.start("Creating monorepo workspace...");
+  try {
+    const { files } = generateMonorepo({
+      name: generateOptions.name,
+      linter: generateOptions.linter ?? "oxlint",
+      formatter: generateOptions.formatter ?? "oxfmt",
+      packageManager,
+      pnpmVersion: generateOptions.pnpmVersion,
+      pnpmManageVersions: generateOptions.pnpmManageVersions,
+      nodeVersion: generateOptions.nodeVersion,
+      aiFiles: selectedAiFiles.length > 0 ? selectedAiFiles : void 0
+    });
+    const filePaths = Object.keys(files).sort();
+    for (const filePath of filePaths) {
+      const fullFilePath = join(projectPath, filePath);
+      await mkdir(dirname(fullFilePath), { recursive: true });
+      const file = files[filePath];
+      if (file.type === "text") {
+        await writeFile(fullFilePath, file.content);
+      }
+    }
+    spinner.stop(color.green.inverse(" \u2713 Monorepo workspace created! "));
+    const newMonorepoTooling = {
+      linter: generateOptions.linter,
+      formatter: generateOptions.formatter
+    };
+    const scope = generateOptions.name;
+    let addMore = true;
+    while (addMore) {
+      addMore = await createPackageInWorkspace(
+        projectPath,
+        packageManager,
+        newMonorepoTooling,
+        scope
+      );
+    }
+    const nextSteps = [
+      `cd ${generateOptions.name}`,
+      `${packageManager} install`,
+      `${packageManager} run dev`
+    ].join("\n");
+    p.note(nextSteps, "Next steps");
+    await promptAndOpenEditor(projectPath);
+    p.outro(color.green("Happy coding! \u2728"));
+    process.exit(0);
+  } catch (error) {
+    spinner.stop("Failed to create monorepo workspace");
+    p.log.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleStandaloneProjectCreation(generateOptions) {
+  const base = generateOptions.template ? getBaseTemplate(generateOptions.template) : "vanilla";
+  const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
+  generateOptions.name ??= defaultFallbackName;
+  const packageManager = generateOptions.packageManager || "pnpm";
+  if (packageManager === "pnpm") {
+    generateOptions.pnpmVersion = await getLatestPnpmVersion();
+  } else if (packageManager === "yarn") {
+    generateOptions.yarnVersion = await getLatestYarnVersion();
+  } else if (packageManager === "npm") {
+    generateOptions.npmVersion = await getLatestNpmCliVersion();
+  }
+  const nodeVersion = generateOptions.nodeVersion ?? "latest";
+  if (nodeVersion === "latest") {
+    generateOptions.nodeVersion = await getLatestNodeVersion();
+  }
+  const versions = {};
+  const versionPromises = [];
+  const isLibrary = generateOptions.projectType === "library";
+  const testing = generateOptions.testing ?? (isLibrary ? "vitest" : "none");
+  if (testing === "vitest") {
+    versionPromises.push(
+      getLatestNpmVersion("vitest", "4.0.0").then((v) => {
+        versions.vitest = v;
+      })
+    );
+  }
+  if (!isLibrary) {
+    versionPromises.push(
+      getLatestNpmVersion("vite", "6.3.4").then((v) => {
+        versions.vite = v;
+      })
+    );
+  }
+  const linter = generateOptions.linter ?? "oxlint";
+  if (linter === "eslint") {
+    versionPromises.push(
+      getLatestNpmVersion("eslint", "9.17.0").then((v) => {
+        versions.eslint = v;
+      })
+    );
+  } else if (linter === "oxlint") {
+    versionPromises.push(
+      getLatestNpmVersion("oxlint", "0.16.0").then((v) => {
+        versions.oxlint = v;
+      })
+    );
+  } else if (linter === "biome") {
+    versionPromises.push(
+      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
+        versions.biome = v;
+      })
+    );
+  }
+  const formatter = generateOptions.formatter ?? "oxfmt";
+  if (formatter === "prettier") {
+    versionPromises.push(
+      getLatestNpmVersion("prettier", "3.4.2").then((v) => {
+        versions.prettier = v;
+      })
+    );
+  } else if (formatter === "oxfmt") {
+    versionPromises.push(
+      getLatestNpmVersion("oxfmt", "0.1.0").then((v) => {
+        versions.oxfmt = v;
+      })
+    );
+  } else if (formatter === "biome" && linter !== "biome") {
+    versionPromises.push(
+      getLatestNpmVersion("@biomejs/biome", "1.9.4").then((v) => {
+        versions.biome = v;
+      })
+    );
+  }
+  await Promise.all(versionPromises);
+  generateOptions.versions = versions;
+  const projectPath = join(cwd(), generateOptions.name);
+  const spinner = p.spinner();
+  spinner.start("Creating project...");
+  try {
+    const files = generate(generateOptions);
+    await writeGeneratedFiles(projectPath, files);
+    spinner.stop(color.green.inverse(" \u2713 Project created! "));
+    const nextSteps = isLibrary ? [
+      `cd ${generateOptions.name}`,
+      `${packageManager} install`,
+      `${packageManager} run build`
+    ].join("\n") : [
+      `cd ${generateOptions.name}`,
+      `${packageManager} install`,
+      `${packageManager} run dev`
+    ].join("\n");
+    p.note(nextSteps, "Next steps");
+    await promptAndOpenEditor(projectPath);
+    p.outro(color.green("Happy coding! \u2728"));
+  } catch (error) {
+    spinner.stop("Failed to create project");
+    p.log.error(String(error));
+    process.exit(1);
+  }
+}
+async function handleInteractiveMonorepoMode(monorepoRoot) {
+  const choice = await p.select({
+    message: "Detected monorepo workspace",
+    options: [
+      { value: "add", label: "Add new package to this workspace" },
+      { value: "standalone", label: "Create standalone project" }
+    ],
+    initialValue: "add"
+  });
+  if (p.isCancel(choice)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  if (choice === "add") {
+    const inheritedTooling = await detectWorkspaceTooling(monorepoRoot);
+    if (inheritedTooling.linter || inheritedTooling.formatter) {
+      const toolingInfo = [
+        inheritedTooling.linter && `linter: ${inheritedTooling.linter}`,
+        inheritedTooling.formatter && `formatter: ${inheritedTooling.formatter}`
+      ].filter(Boolean).join(", ");
+      p.log.info(`Using workspace tooling (${toolingInfo})`);
+    }
+    const scope = await getMonorepoScope(monorepoRoot);
+    let addMore = true;
+    while (addMore) {
+      addMore = await createPackageInWorkspace(
+        monorepoRoot,
+        "pnpm",
+        inheritedTooling,
+        scope
+      );
+    }
+    p.note(
+      [`cd ${monorepoRoot}`, "pnpm install", "pnpm run dev"].join("\n"),
+      "Next steps"
+    );
+    await promptAndOpenEditor(monorepoRoot);
+    p.outro(color.green("Happy coding! \u2728"));
+    process.exit(0);
+  }
+}
+async function main() {
+  const program = new Command().name("create-krispya").description(
+    "CLI for creating Vanilla, React, and React Three Fiber projects"
+  ).argument("[name]", "name for the project").option("--type <type>", "project type: app or library (default: app)").option(
+    "--bundler <bundler>",
+    "library bundler: unbuild or tsdown (default: unbuild, only for libraries)"
+  ).option(
+    "--template <type>",
+    "project template: vanilla, vanilla-js, react, react-js, r3f, r3f-js (default: vanilla)"
+  ).option(
+    "--linter <type>",
+    "linter: eslint, oxlint, or biome (default: oxlint)"
+  ).option(
+    "--formatter <type>",
+    "formatter: prettier, oxfmt, or biome (default: oxfmt)"
+  ).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(
+    "--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;
+        default:
+          console.error(color.red(`Unknown option: ${name}`));
+          process.exit(1);
       }
-      p.outro(color.green("Happy coding! \u2728"));
-    } catch (error) {
-      s.stop("Failed to create project");
-      p.log.error(String(error));
+    }
+    if (options.check) {
+      await handleCheckCommand();
+    }
+    if (options.fix) {
+      await handleFixCommand(options);
+    }
+    if (options.dir && !options.workspace) {
+      console.error(color.red("Error:") + " --dir requires --workspace flag");
+      console.log(
+        color.dim(
+          "  Example: pnpm create krispya my-lib --workspace --dir examples"
+        )
+      );
       process.exit(1);
     }
+    if (options.workspace) {
+      await handleWorkspaceCommand(name, options);
+    }
+    console.clear();
+    p.intro(color.bgCyan(color.black(` create-krispya v${pkg.version} `)));
+    const monorepoRoot = await detectMonorepoRoot();
+    if (monorepoRoot && Object.keys(options).length === 0) {
+      await handleInteractiveMonorepoMode(monorepoRoot);
+    }
+    let generateOptions;
+    if (Object.keys(options).length > 0) {
+      const template = options.template ?? "vanilla";
+      const baseTemplate = getBaseTemplate(template);
+      const defaultName = getDefaultProjectName(template);
+      const projectType = options.type ?? "app";
+      generateOptions = {
+        name: name || defaultName,
+        projectType,
+        libraryBundler: projectType === "library" ? options.bundler ?? "unbuild" : void 0,
+        template,
+        linter: options.linter ?? "oxlint",
+        formatter: options.formatter ?? "oxfmt",
+        ...baseTemplate === "r3f" && {
+          drei: options.drei ? {} : void 0,
+          handle: options.handle ? {} : void 0,
+          leva: options.leva ? {} : void 0,
+          postprocessing: options.postprocessing ? {} : void 0,
+          rapier: options.rapier ? {} : void 0,
+          xr: options.xr ? {} : void 0,
+          uikit: options.uikit ? {} : void 0,
+          offscreen: options.offscreen ? {} : void 0,
+          zustand: options.zustand ? {} : void 0,
+          koota: options.koota ? {} : void 0,
+          viverse: options.viverse ? {} : void 0,
+          triplex: options.triplex ? {} : void 0
+        },
+        packageManager: options.packageManager,
+        pnpmManageVersions: options.pnpmManageVersions,
+        nodeVersion: options.nodeVersion ?? "latest"
+      };
+    } else {
+      generateOptions = await promptForOptions(name);
+    }
+    if (generateOptions.projectType === "monorepo") {
+      await handleMonorepoCreation(generateOptions);
+    } else {
+      await handleStandaloneProjectCreation(generateOptions);
+    }
   });
   await program.parseAsync();
 }