create-krispya 0.5.1 → 0.5.3

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 = {
@@ -138,6 +138,12 @@ function getReuseWindow() {
 function setReuseWindow(reuse) {
   config.set("reuseWindow", reuse);
 }
+function getAiFiles() {
+  return config.get("aiFiles");
+}
+function setAiFiles(files) {
+  config.set("aiFiles", files);
+}
 function clearConfig() {
   config.clear();
 }
@@ -425,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: [
@@ -480,8 +469,8 @@ async function promptForMonorepoCustomization(name) {
     name,
     projectType: "monorepo",
     nodeVersion,
-    packageManager,
-    pnpmManageVersions,
+    packageManager: "pnpm",
+    pnpmManageVersions: managePnpm,
     linter,
     formatter
   };
@@ -665,15 +654,86 @@ async function promptForPackageOptions(projectName, projectType, inheritedToolin
   return promptForCustomization(template, projectName, projectType, integrations, inheritedTooling);
 }
 
+async function checkAnyExists(paths) {
+  for (const path of paths) {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function validateWorkspace(monorepoRoot) {
+  const errors = [];
+  const tsConfigPath = join(monorepoRoot, ".config/typescript/package.json");
+  try {
+    await access(tsConfigPath, constants.F_OK);
+  } catch {
+    errors.push("Missing .config/typescript package");
+  }
+  const linterPaths = [
+    join(monorepoRoot, ".config/oxlint/package.json"),
+    join(monorepoRoot, ".config/eslint/package.json"),
+    join(monorepoRoot, "eslint.config.js"),
+    join(monorepoRoot, "biome.json")
+  ];
+  const hasLinter = await checkAnyExists(linterPaths);
+  if (!hasLinter) {
+    errors.push(
+      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
+    );
+  }
+  const formatterPaths = [
+    join(monorepoRoot, ".config/oxfmt/package.json"),
+    join(monorepoRoot, ".config/prettier/package.json"),
+    join(monorepoRoot, ".prettierrc.json"),
+    join(monorepoRoot, "biome.json")
+  ];
+  const hasFormatter = await checkAnyExists(formatterPaths);
+  if (!hasFormatter) {
+    errors.push(
+      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
+    );
+  }
+  return { valid: errors.length === 0, errors };
+}
+
 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;
@@ -684,12 +744,21 @@ async function detectMonorepoRoot() {
   }
   return null;
 }
+async function parseWorkspaceDirectories(monorepoRoot) {
+  try {
+    const workspaceFile = join(monorepoRoot, "pnpm-workspace.yaml");
+    const content = await readFile(workspaceFile, "utf-8");
+    return parseWorkspaceYamlContent(content);
+  } catch {
+    return [];
+  }
+}
 async function detectWorkspaceTooling(monorepoRoot) {
   try {
     const pkgPath = join(monorepoRoot, "package.json");
     const content = await readFile(pkgPath, "utf-8");
-    const pkg2 = JSON.parse(content);
-    const devDeps = pkg2.devDependencies ?? {};
+    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 };
@@ -697,13 +766,33 @@ async function detectWorkspaceTooling(monorepoRoot) {
     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 pkg2 = JSON.parse(content);
-    if (pkg2.name) {
-      return pkg2.name.replace(/^@/, "").replace(/\/.*$/, "");
+    const pkgJson = JSON.parse(content);
+    if (pkgJson.name) {
+      return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
     }
   } catch {
   }
@@ -711,56 +800,264 @@ async function getMonorepoScope(monorepoRoot) {
 }
 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 });
+    const names = [];
     for (const entry of entries) {
-      if (entry.isDirectory()) {
-        try {
-          const pkgJsonPath = join(packagesDir, entry.name, "package.json");
-          const content = await readFile(pkgJsonPath, "utf-8");
-          const pkg2 = JSON.parse(content);
-          if (pkg2.name) {
-            packages.push({ name: pkg2.name, path: `packages/${entry.name}` });
-          }
-        } catch {
-        }
+      if (!entry.isDirectory()) continue;
+      try {
+        const content = await readFile(
+          join(packagesDir, entry.name, "package.json"),
+          "utf-8"
+        );
+        const pkg2 = JSON.parse(content);
+        if (pkg2.name) names.push(pkg2.name);
+      } catch {
       }
     }
+    return names;
+  } catch {
+    return [];
+  }
+}
+async function ensureConfigInWorkspace(monorepoRoot) {
+  const workspacePath = join(monorepoRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile(workspacePath, "utf-8");
+  } catch {
+    content = `packages:
+  - ".config/*"
+  - "packages/*"
+`;
+    await writeFile(workspacePath, content);
+    return;
+  }
+  if (content.includes(".config/*") || content.includes('".config/*"')) {
+    return;
+  }
+  const lines = content.split("\n");
+  const packagesIndex = lines.findIndex(
+    (line) => line.trim().startsWith("packages:")
+  );
+  if (packagesIndex === -1) {
+    content = `packages:
+  - ".config/*"
+${content}`;
+  } else {
+    lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
+    content = lines.join("\n");
+  }
+  await writeFile(workspacePath, content);
+}
+async function migrateEslintConfig(monorepoRoot, files) {
+  const configBasePath = ".config/eslint";
+  const existingConfigPath = join(monorepoRoot, "eslint.config.js");
+  let existingContent;
+  try {
+    existingContent = await readFile(existingConfigPath, "utf-8");
+  } catch {
+    generateEslintConfigPackage(files);
+    return;
+  }
+  files[`${configBasePath}/package.json`] = {
+    type: "text",
+    content: JSON.stringify(
+      {
+        name: "@config/eslint",
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        exports: {
+          "./base": "./base.js",
+          "./react": "./react.js"
+        }
+      },
+      null,
+      2
+    )
+  };
+  files[`${configBasePath}/README.md`] = {
+    type: "text",
+    content: `# \`@config/eslint\`
+
+Shared ESLint configurations.
+
+## Usage
+
+In your package's \`eslint.config.js\`:
+
+\`\`\`js
+import base from "@config/eslint/base";
+
+export default [...base];
+\`\`\`
+
+## Available Configs
+
+- \`base\` - Base ESLint rules (migrated from root)
+- \`react\` - React-specific rules
+`
+  };
+  files[`${configBasePath}/base.js`] = {
+    type: "text",
+    content: existingContent
+  };
+  files[`${configBasePath}/react.js`] = {
+    type: "text",
+    content: `import react from "eslint-plugin-react";
+import reactHooks from "eslint-plugin-react-hooks";
+
+export default [
+  {
+    plugins: {
+      react,
+      "react-hooks": reactHooks,
+    },
+    rules: {
+      ...react.configs.recommended.rules,
+      ...reactHooks.configs.recommended.rules,
+      "react/react-in-jsx-scope": "off",
+    },
+    settings: {
+      react: {
+        version: "detect",
+      },
+    },
+  },
+];
+`
+  };
+}
+async function migratePrettierConfig(monorepoRoot, files) {
+  const configBasePath = ".config/prettier";
+  const existingConfigPath = join(monorepoRoot, ".prettierrc.json");
+  let existingContent;
+  try {
+    existingContent = await readFile(existingConfigPath, "utf-8");
   } catch {
+    generatePrettierConfigPackage(files);
+    return;
   }
-  return packages;
+  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?",
-    placeholder: `Scoped to @${scope}/`,
+    initialValue: `@${scope}/`,
     validate: (value) => {
-      if (!value.length) return "Package name is required";
+      const validationError = validatePackageName(value);
+      if (validationError) return validationError;
+      const dirName = value.includes("/") ? value.split("/").pop() : value;
+      if (!dirName) return "Package name is required";
+      if (!hasCustomDirectories) {
+        const targetPath = join(monorepoRoot, defaultDir, dirName);
+        try {
+          const { statSync } = require$1("fs");
+          statSync(targetPath);
+          return `Directory ${defaultDir}/${dirName} already exists`;
+        } catch {
+        }
+      }
     }
   });
   if (p.isCancel(packageNameInput)) {
     return false;
   }
-  const shortName = packageNameInput;
-  const scopedName = `@${scope}/${shortName}`;
-  const targetDir = packageType === "app" ? "apps" : "packages";
-  const packagePath = join(targetDir, shortName);
-  const workspaceRoot = "../..";
+  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") {
@@ -826,40 +1123,26 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedT
   }
   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((pkg2) => ({
-          value: pkg2.name,
-          label: pkg2.name.replace(/^@[^/]+\//, "")
-        })),
-        required: false
-      });
-      if (!p.isCancel(selectedDeps) && selectedDeps.length > 0) {
-        packageOptions.workspaceDependencies = selectedDeps;
-      }
+  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
+  if (workspacePackages.length > 0) {
+    const selectedDeps = await p.multiselect({
+      message: "Add workspace dependencies?",
+      options: workspacePackages.map((name) => ({ value: name, label: name })),
+      required: false
+    });
+    if (!p.isCancel(selectedDeps) && selectedDeps.length > 0) {
+      packageOptions.workspaceDependencies = selectedDeps;
     }
   }
-  const basePath = join(monorepoRoot, packagePath);
-  const s = p.spinner();
-  s.start("Creating package...");
+  const outputPath = join(monorepoRoot, relativePkgPath);
+  const spinner = p.spinner();
+  spinner.start("Creating package...");
   try {
     const files = generate(packageOptions);
-    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);
-      }
-    }
-    s.stop(color.green.inverse(` \u2713 Package created at ${packagePath}! `));
+    await writeGeneratedFiles(outputPath, files);
+    spinner.stop(
+      color.green.inverse(` \u2713 Package created at ${relativePkgPath}! `)
+    );
     const addAnother = await p.select({
       message: "Add another package?",
       options: [
@@ -870,12 +1153,12 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedT
     });
     return !p.isCancel(addAnother) && addAnother === "yes";
   } catch (error) {
-    s.stop("Failed to create package");
+    spinner.stop("Failed to create package");
     p.log.error(String(error));
     return false;
   }
 }
-async function promptAndOpenEditor(basePath) {
+async function promptAndOpenEditor(projectPath) {
   const savedEditor = getPreferredEditor();
   let selectedEditor;
   if (savedEditor && savedEditor !== "skip") {
@@ -925,7 +1208,7 @@ async function promptAndOpenEditor(basePath) {
     try {
       await openInEditor(
         selectedEditor,
-        basePath,
+        projectPath,
         getReuseWindow()
       );
       p.log.success(`Opening in ${editorNames[selectedEditor]}...`);
@@ -936,14 +1219,673 @@ async function promptAndOpenEditor(basePath) {
     }
   }
 }
+async function handleCheckCommand() {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color.red("\u2717") + " Not a monorepo workspace");
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color.green("\u2713") + " Valid monorepo workspace");
+    console.log(color.dim(`  ${monorepoRoot}`));
+  } else {
+    console.log(color.red("\u2717") + " Invalid monorepo workspace");
+    console.log(color.dim(`  ${monorepoRoot}`));
+    for (const error of errors) {
+      console.log(color.red(`  \u2022 ${error}`));
+    }
+  }
+  process.exit(valid ? 0 : 1);
+}
+async function handleFixCommand(options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color.red("\u2717") + " Not a monorepo workspace");
+    console.log(color.dim("  Run this command from within a monorepo"));
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color.green("\u2713") + " Workspace is already valid");
+    console.log(color.dim(`  ${monorepoRoot}`));
+    process.exit(0);
+  }
+  console.log(color.yellow("!") + " Invalid monorepo workspace");
+  for (const error of errors) {
+    console.log(color.dim(`  \u2022 ${error}`));
+  }
+  console.log();
+  const tooling = await 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);
+    }
+    const formatterChoice = await p.select({
+      message: "Formatter",
+      options: [
+        {
+          value: "oxfmt",
+          label: "oxfmt" + (tooling.formatter === "oxfmt" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "prettier",
+          label: "prettier" + (tooling.formatter === "prettier" || existingConfigs.formatter === "prettier" ? color.dim(" (installed)") : "")
+        },
+        {
+          value: "biome",
+          label: "biome" + (tooling.formatter === "biome" ? color.dim(" (installed)") : "")
+        }
+      ],
+      initialValue: detectedFormatter
+    });
+    if (p.isCancel(formatterChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    linter = linterChoice;
+    formatter = formatterChoice;
+  }
+  console.log();
+  const spinner = p.spinner();
+  spinner.start("Fixing workspace...");
+  try {
+    const files = {};
+    const tsConfigExists = await fileExists(
+      join(monorepoRoot, ".config/typescript/package.json")
+    );
+    if (!tsConfigExists) {
+      generateTypescriptConfigPackage(files);
+    }
+    if (linter === "oxlint") {
+      const oxlintExists = await fileExists(
+        join(monorepoRoot, ".config/oxlint/package.json")
+      );
+      if (!oxlintExists) generateOxlintConfigPackage(files);
+    } else if (linter === "eslint") {
+      const eslintPkgExists = await fileExists(
+        join(monorepoRoot, ".config/eslint/package.json")
+      );
+      if (!eslintPkgExists) {
+        if (existingConfigs.eslintConfigPath) {
+          await migrateEslintConfig(monorepoRoot, files);
+        } else {
+          generateEslintConfigPackage(files);
+        }
+      }
+    }
+    if (formatter === "oxfmt") {
+      const oxfmtExists = await fileExists(
+        join(monorepoRoot, ".config/oxfmt/package.json")
+      );
+      if (!oxfmtExists) generateOxfmtConfigPackage(files);
+    } else if (formatter === "prettier") {
+      const prettierPkgExists = await fileExists(
+        join(monorepoRoot, ".config/prettier/package.json")
+      );
+      if (!prettierPkgExists) {
+        if (existingConfigs.prettierConfigPath) {
+          await migratePrettierConfig(monorepoRoot, files);
+        } else {
+          generatePrettierConfigPackage(files);
+        }
+      }
+    }
+    if ((linter === "biome" || formatter === "biome") && !existingConfigs.biomeConfigPath) {
+      const biomeConfig = {
+        $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+        vcs: {
+          enabled: true,
+          clientKind: "git",
+          useIgnoreFile: true
+        },
+        linter: {
+          enabled: linter === "biome",
+          rules: {
+            recommended: true
+          }
+        },
+        formatter: {
+          enabled: formatter === "biome"
+        }
+      };
+      files["biome.json"] = {
+        type: "text",
+        content: JSON.stringify(biomeConfig, null, 2)
+      };
+    }
+    for (const [filePath, file] of Object.entries(files)) {
+      const fullPath = join(monorepoRoot, filePath);
+      await mkdir(dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, file.content);
+    }
+    await ensureConfigInWorkspace(monorepoRoot);
+    if (existingConfigs.eslintConfigPath && linter === "eslint") {
+      try {
+        await unlink(existingConfigs.eslintConfigPath);
+      } catch {
+      }
+    }
+    if (existingConfigs.prettierConfigPath && formatter === "prettier") {
+      try {
+        await unlink(existingConfigs.prettierConfigPath);
+      } catch {
+      }
+    }
+    spinner.stop(color.green("\u2713") + " Workspace fixed!");
+    const generated = Object.keys(files).filter(
+      (f) => f.endsWith("package.json")
+    );
+    for (const pkgFile of generated) {
+      const pkgName = pkgFile.replace("/package.json", "");
+      console.log(color.dim(`  Generated ${pkgName}`));
+    }
+    const vscodeSettingsExists = await fileExists(
+      join(monorepoRoot, ".vscode/settings.json")
+    );
+    const vscodeExtensionsExists = await fileExists(
+      join(monorepoRoot, ".vscode/extensions.json")
+    );
+    const vscodeExists = vscodeSettingsExists && vscodeExtensionsExists;
+    if (!vscodeExists) {
+      let addVscode = false;
+      if (isNonInteractive) {
+        addVscode = true;
+      } else {
+        const vscodeChoice = await p.confirm({
+          message: "Generate VS Code settings?",
+          initialValue: true
+        });
+        addVscode = !p.isCancel(vscodeChoice) && vscodeChoice;
+      }
+      if (addVscode) {
+        const vscodeFiles = {};
+        generateVscodeFiles(vscodeFiles, linter, formatter);
+        for (const [filePath, file] of Object.entries(vscodeFiles)) {
+          const fullPath = join(monorepoRoot, filePath);
+          await mkdir(dirname(fullPath), { recursive: true });
+          await writeFile(fullPath, file.content);
+        }
+        console.log(color.dim("  Generated .vscode/settings.json"));
+        console.log(color.dim("  Generated .vscode/extensions.json"));
+      }
+    }
+    const 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: `Generate AI instruction files? ${color.dim(
+            `(${savedLabels})`
+          )}`,
+          initialValue: true
+        });
+        if (!p.isCancel(useDefault) && useDefault) {
+          selectedAiFiles = availableSaved;
+        }
+      }
+    } 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(saveChoice) && saveChoice) {
+          setAiFiles(selectedAiFiles);
+        }
+      }
+    }
+    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(
+  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(
+  ).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(
@@ -952,7 +1894,22 @@ async function main() {
   ).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)").option("--config-path", "Print the path to the config file").action(async (name, options) => {
+  ).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.");
@@ -962,44 +1919,57 @@ async function main() {
       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);
+      }
+    }
+    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) {
-      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);
-      }
+      await handleInteractiveMonorepoMode(monorepoRoot);
     }
     let generateOptions;
     if (Object.keys(options).length > 0) {
@@ -1036,226 +2006,9 @@ async function main() {
       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();
-      }
-      const nodeVersion2 = generateOptions.nodeVersion ?? "latest";
-      if (nodeVersion2 === "latest") {
-        generateOptions.nodeVersion = await getLatestNodeVersion();
-      }
-      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(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(basePath2, packageManager2, newMonorepoTooling, scope);
-        }
-        const nextSteps = [
-          `cd ${generateOptions.name}`,
-          `${packageManager2} install`,
-          `${packageManager2} run dev`
-        ].join("\n");
-        p.note(nextSteps, "Next steps");
-        await promptAndOpenEditor(basePath2);
-        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();
-    }
-    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 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);
-        } else {
-          const response = await fetch(file.url);
-          await writeFile(fullFilePath, response.body);
-        }
-      }
-      s.stop(color.green.inverse(" \u2713 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 useDefault = await p.confirm({
-          message: `Open in editor? ${color.dim(`(${editorNames[savedEditor]})`)}`,
-          initialValue: true
-        });
-        if (p.isCancel(useDefault)) {
-          selectedEditor = void 0;
-        } else if (useDefault) {
-          selectedEditor = savedEditor;
-        } else {
-          selectedEditor = "skip";
-        }
-      } else {
-        const openEditor = await p.select({
-          message: "Open project in editor?",
-          options: [
-            { value: "skip", label: "Skip" },
-            { value: "cursor", label: "Cursor" },
-            { value: "code", label: "VS Code" },
-            { value: "webstorm", label: "WebStorm" }
-          ],
-          initialValue: "skip"
-        });
-        if (!p.isCancel(openEditor)) {
-          selectedEditor = openEditor;
-          const saveChoice = await p.confirm({
-            message: `Save ${editorNames[selectedEditor] ?? "Skip"} as default editor?`,
-            initialValue: true
-          });
-          if (!p.isCancel(saveChoice) && saveChoice) {
-            setPreferredEditor(selectedEditor);
-            if (selectedEditor === "cursor" || selectedEditor === "code") {
-              const reuseChoice = await p.confirm({
-                message: "Reuse current window when opening projects?",
-                initialValue: false
-              });
-              if (!p.isCancel(reuseChoice)) {
-                setReuseWindow(reuseChoice);
-              }
-            }
-          }
-        }
-      }
-      if (selectedEditor && selectedEditor !== "skip") {
-        try {
-          await openInEditor(
-            selectedEditor,
-            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.`
-          );
-        }
-      }
-      p.outro(color.green("Happy coding! \u2728"));
-    } catch (error) {
-      s.stop("Failed to create project");
-      p.log.error(String(error));
-      process.exit(1);
+      await handleMonorepoCreation(generateOptions);
+    } else {
+      await handleStandaloneProjectCreation(generateOptions);
     }
   });
   await program.parseAsync();