create-krispya 0.5.2 → 0.6.0

package/dist/cli.cjs

@@ -58,14 +58,15 @@ function openInEditor(editor, path, reuseWindow) {
   });
 }
 
-function formatConfigSummary(options) {
+function formatConfigSummary(options, inherited) {
   const lines = [];
   const VALUE_COL = 27;
-  const formatRow = (label, value, indent = "") => {
+  const formatRow = (label, value, isInherited = false, indent = "") => {
     const fullLabel = indent + label;
     const dotCount = Math.max(1, VALUE_COL - fullLabel.length - 1);
     const dots = color__default.gray(".".repeat(dotCount));
-    return `${indent}${label} ${dots} ${value}`;
+    const displayValue = isInherited ? `${value} \u{1F512}` : value;
+    return `${indent}${label} ${dots} ${displayValue}`;
   };
   const formatLanguage = (lang) => {
     return lang === "typescript" ? "TypeScript" : lang === "javascript" ? "JavaScript" : lang;
@@ -84,20 +85,29 @@ function formatConfigSummary(options) {
   } else {
     lines.push(formatRow("Bundler", "vite"));
   }
-  lines.push(formatRow("Node version", options.nodeVersion || "latest"));
-  lines.push(formatRow("Package manager", options.packageManager || "pnpm"));
+  const nodeVersionInherited = inherited?.nodeVersion !== void 0;
+  lines.push(formatRow("Node version", options.nodeVersion || "latest", nodeVersionInherited));
+  const pmInherited = inherited?.packageManager !== void 0;
+  lines.push(formatRow("Package manager", options.packageManager || "pnpm", pmInherited));
   if (options.packageManager === "pnpm") {
     const versionManaged = options.pnpmManageVersions ? "yes" : "no";
-    lines.push(formatRow("\u21B3 Version managed", versionManaged, ""));
+    const pnpmVersionInherited = inherited?.pnpmManageVersions !== void 0;
+    lines.push(formatRow("\u21B3 Version managed", versionManaged, pnpmVersionInherited, ""));
   }
   if (options.linter) {
-    lines.push(formatRow("Linter", options.linter));
+    const linterInherited = inherited?.linter !== void 0;
+    lines.push(formatRow("Linter", options.linter, linterInherited));
   }
   if (options.formatter) {
-    lines.push(formatRow("Formatter", options.formatter));
+    const formatterInherited = inherited?.formatter !== void 0;
+    lines.push(formatRow("Formatter", options.formatter, formatterInherited));
   }
   const testing = options.testing ?? (projectType === "library" ? "vitest" : "none");
   lines.push(formatRow("Testing", testing));
+  if (!inherited) {
+    const configStrategy = options.configStrategy ?? "stealth";
+    lines.push(formatRow("Config strategy", configStrategy));
+  }
   if (options.template && index.getBaseTemplate(options.template) === "r3f") {
     const integrationNames = [
       options.drei && "drei",
@@ -159,11 +169,14 @@ function getReuseWindow() {
 function setReuseWindow(reuse) {
   config.set("reuseWindow", reuse);
 }
-function getAiFiles() {
-  return config.get("aiFiles");
+function getAiPlatforms() {
+  return config.get("aiPlatforms");
+}
+function setAiPlatforms(platforms) {
+  config.set("aiPlatforms", platforms);
 }
-function setAiFiles(files) {
-  config.set("aiFiles", files);
+function getConfigStrategy() {
+  return config.get("configStrategy") ?? "stealth";
 }
 function clearConfig() {
   config.clear();
@@ -175,20 +188,21 @@ function getCustomTemplates() {
   return config.get("customTemplates") ?? {};
 }
 
-function getDefaultOptions(template, name, projectType = "app", libraryBundler, integrations, inheritedTooling) {
+function getDefaultOptions(template, name, projectType = "app", libraryBundler, integrations, inheritedSettings) {
   const baseTemplate = index.getBaseTemplate(template);
   const base = {
     name,
     template,
     projectType,
     libraryBundler: projectType === "library" ? libraryBundler ?? "unbuild" : void 0,
-    packageManager: "pnpm",
-    pnpmManageVersions: true,
-    nodeVersion: "latest",
-    linter: inheritedTooling?.linter ?? "oxlint",
-    formatter: inheritedTooling?.formatter ?? "oxfmt",
+    packageManager: inheritedSettings?.packageManager ?? "pnpm",
+    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
+    nodeVersion: inheritedSettings?.nodeVersion ?? "latest",
+    linter: inheritedSettings?.linter ?? "oxlint",
+    formatter: inheritedSettings?.formatter ?? "prettier",
     // Libraries get vitest by default, apps don't
-    testing: projectType === "library" ? "vitest" : "none"
+    testing: projectType === "library" ? "vitest" : "none",
+    configStrategy: getConfigStrategy()
   };
   if (baseTemplate === "r3f" && integrations) {
     return {
@@ -220,7 +234,22 @@ function getDefaultProjectName(template) {
       return `react-three-${index.generateRandomName()}`;
   }
 }
-async function promptForR3fIntegrations() {
+async function promptForR3fIntegrations(presets) {
+  const initialValues = [];
+  if (presets) {
+    if (presets.drei) initialValues.push("drei");
+    if (presets.handle) initialValues.push("handle");
+    if (presets.leva) initialValues.push("leva");
+    if (presets.postprocessing) initialValues.push("postprocessing");
+    if (presets.rapier) initialValues.push("rapier");
+    if (presets.xr) initialValues.push("xr");
+    if (presets.uikit) initialValues.push("uikit");
+    if (presets.offscreen) initialValues.push("offscreen");
+    if (presets.zustand) initialValues.push("zustand");
+    if (presets.koota) initialValues.push("koota");
+    if (presets.triplex) initialValues.push("triplex");
+    if (presets.viverse) initialValues.push("viverse");
+  }
   const selected = await p__namespace.multiselect({
     message: "R3F integrations",
     options: [
@@ -237,7 +266,7 @@ async function promptForR3fIntegrations() {
       { value: "triplex", label: "Triplex" },
       { value: "viverse", label: "Viverse" }
     ],
-    initialValues: ["drei"],
+    initialValues: initialValues.length > 0 ? initialValues : ["drei"],
     required: false
   });
   if (p__namespace.isCancel(selected)) {
@@ -246,7 +275,7 @@ async function promptForR3fIntegrations() {
   }
   return selected;
 }
-async function promptForCustomization(template, name, projectType, integrations, inheritedTooling) {
+async function promptForCustomization(template, name, projectType, integrations, inheritedSettings, presets) {
   let libraryBundler;
   if (projectType === "library") {
     const bundler = await p__namespace.select({
@@ -255,7 +284,7 @@ async function promptForCustomization(template, name, projectType, integrations,
         { value: "unbuild", label: "unbuild", hint: "unjs, simple config" },
         { value: "tsdown", label: "tsdown", hint: "fast, esbuild-based" }
       ],
-      initialValue: "unbuild"
+      initialValue: presets?.bundler ?? "unbuild"
     });
     if (p__namespace.isCancel(bundler)) {
       p__namespace.cancel("Operation cancelled.");
@@ -263,64 +292,57 @@ async function promptForCustomization(template, name, projectType, integrations,
     }
     libraryBundler = bundler;
   }
-  const nodeVersion = await p__namespace.text({
-    message: "Node.js version",
-    placeholder: "latest",
-    defaultValue: "latest",
-    validate: (value) => {
-      if (!value.length) return "Required";
-      if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
-        return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
-      }
-    }
-  });
-  if (p__namespace.isCancel(nodeVersion)) {
-    p__namespace.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  const packageManager = await p__namespace.select({
-    message: "Package manager",
-    options: [
-      { value: "pnpm", label: "pnpm" },
-      { value: "npm", label: "npm" },
-      { value: "yarn", label: "yarn" },
-      { value: "custom", label: "Other (custom)" }
-    ],
-    initialValue: "pnpm"
-  });
-  if (p__namespace.isCancel(packageManager)) {
-    p__namespace.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  let finalPackageManager = packageManager;
-  if (packageManager === "custom") {
-    const customPm = await p__namespace.text({
-      message: "Enter package manager command",
+  let nodeVersion = inheritedSettings?.nodeVersion ?? presets?.nodeVersion ?? "latest";
+  let finalPackageManager = inheritedSettings?.packageManager ?? presets?.packageManager ?? "pnpm";
+  let pnpmManageVersions = inheritedSettings?.pnpmManageVersions ?? presets?.pnpmManageVersions ?? true;
+  if (!inheritedSettings?.nodeVersion) {
+    const nodeVersionInput = await p__namespace.text({
+      message: "Node.js version",
+      placeholder: presets?.nodeVersion ?? "latest",
+      defaultValue: presets?.nodeVersion ?? "latest",
       validate: (value) => {
         if (!value.length) return "Required";
+        if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
+          return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
+        }
       }
     });
-    if (p__namespace.isCancel(customPm)) {
+    if (p__namespace.isCancel(nodeVersionInput)) {
       p__namespace.cancel("Operation cancelled.");
       process.exit(0);
     }
-    finalPackageManager = customPm;
+    nodeVersion = nodeVersionInput;
   }
-  let pnpmManageVersions = true;
-  if (packageManager === "pnpm") {
-    const managePnpm = await p__namespace.confirm({
-      message: "Enable manage-package-manager-versions?",
-      initialValue: true
+  if (!inheritedSettings?.packageManager) {
+    const packageManager = await p__namespace.select({
+      message: "Package manager",
+      options: [
+        { value: "pnpm", label: "pnpm" },
+        { value: "npm", label: "npm" },
+        { value: "yarn", label: "yarn" }
+      ],
+      initialValue: presets?.packageManager ?? "pnpm"
     });
-    if (p__namespace.isCancel(managePnpm)) {
+    if (p__namespace.isCancel(packageManager)) {
       p__namespace.cancel("Operation cancelled.");
       process.exit(0);
     }
-    pnpmManageVersions = managePnpm;
+    finalPackageManager = packageManager;
+    if (packageManager === "pnpm") {
+      const managePnpm = await p__namespace.confirm({
+        message: "Enable manage-package-manager-versions?",
+        initialValue: presets?.pnpmManageVersions ?? true
+      });
+      if (p__namespace.isCancel(managePnpm)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      pnpmManageVersions = managePnpm;
+    }
   }
-  let linter = inheritedTooling?.linter ?? "oxlint";
-  let formatter = inheritedTooling?.formatter ?? "oxfmt";
-  if (!inheritedTooling?.linter) {
+  let linter = inheritedSettings?.linter ?? presets?.linter ?? "oxlint";
+  let formatter = inheritedSettings?.formatter ?? presets?.formatter ?? "prettier";
+  if (!inheritedSettings?.linter) {
     const linterChoice = await p__namespace.select({
       message: "Linter",
       options: [
@@ -328,7 +350,7 @@ async function promptForCustomization(template, name, projectType, integrations,
         { value: "eslint", label: "ESLint", hint: "classic" },
         { value: "biome", label: "Biome", hint: "all-in-one" }
       ],
-      initialValue: "oxlint"
+      initialValue: presets?.linter ?? "oxlint"
     });
     if (p__namespace.isCancel(linterChoice)) {
       p__namespace.cancel("Operation cancelled.");
@@ -336,15 +358,15 @@ async function promptForCustomization(template, name, projectType, integrations,
     }
     linter = linterChoice;
   }
-  if (!inheritedTooling?.formatter) {
+  if (!inheritedSettings?.formatter) {
     const formatterChoice = await p__namespace.select({
       message: "Formatter",
       options: [
+        { value: "prettier", label: "Prettier", hint: "widely adopted" },
         { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
-        { value: "prettier", label: "Prettier", hint: "classic" },
         { value: "biome", label: "Biome", hint: "all-in-one" }
       ],
-      initialValue: "oxfmt"
+      initialValue: presets?.formatter ?? "prettier"
     });
     if (p__namespace.isCancel(formatterChoice)) {
       p__namespace.cancel("Operation cancelled.");
@@ -376,6 +398,18 @@ async function promptForCustomization(template, name, projectType, integrations,
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
+  const configStrategyChoice = await p__namespace.select({
+    message: "Config strategy",
+    options: [
+      { value: "stealth", label: "stealth", hint: "configs in .config/" },
+      { value: "root", label: "root", hint: "configs at project root" }
+    ],
+    initialValue: getConfigStrategy()
+  });
+  if (p__namespace.isCancel(configStrategyChoice)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
   const baseTemplate = index.getBaseTemplate(template);
   const finalTemplate = language === "javascript" ? `${baseTemplate}-js` : baseTemplate;
   const base = {
@@ -388,7 +422,8 @@ async function promptForCustomization(template, name, projectType, integrations,
     pnpmManageVersions,
     linter,
     formatter,
-    testing
+    testing,
+    configStrategy: configStrategyChoice
   };
   if (baseTemplate === "r3f" && integrations) {
     return {
@@ -433,14 +468,14 @@ function getDefaultMonorepoOptions(name) {
     pnpmManageVersions: true,
     nodeVersion: "latest",
     linter: "oxlint",
-    formatter: "oxfmt"
+    formatter: "prettier"
   };
 }
-async function promptForMonorepoCustomization(name) {
+async function promptForMonorepoCustomization(name, presets) {
   const nodeVersion = await p__namespace.text({
     message: "Node.js version",
-    placeholder: "latest",
-    defaultValue: "latest",
+    placeholder: presets?.nodeVersion ?? "latest",
+    defaultValue: presets?.nodeVersion ?? "latest",
     validate: (value) => {
       if (!value.length) return "Required";
       if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
@@ -454,7 +489,7 @@ async function promptForMonorepoCustomization(name) {
   }
   const managePnpm = await p__namespace.confirm({
     message: "Enable manage-package-manager-versions?",
-    initialValue: true
+    initialValue: presets?.pnpmManageVersions ?? true
   });
   if (p__namespace.isCancel(managePnpm)) {
     p__namespace.cancel("Operation cancelled.");
@@ -467,7 +502,7 @@ async function promptForMonorepoCustomization(name) {
       { value: "eslint", label: "ESLint", hint: "classic" },
       { value: "biome", label: "Biome", hint: "all-in-one" }
     ],
-    initialValue: "oxlint"
+    initialValue: presets?.linter ?? "oxlint"
   });
   if (p__namespace.isCancel(linter)) {
     p__namespace.cancel("Operation cancelled.");
@@ -476,11 +511,11 @@ async function promptForMonorepoCustomization(name) {
   const formatter = await p__namespace.select({
     message: "Formatter",
     options: [
+      { value: "prettier", label: "Prettier", hint: "widely adopted" },
       { value: "oxfmt", label: "Oxfmt", hint: "fast, Prettier-compatible" },
-      { value: "prettier", label: "Prettier", hint: "classic" },
       { value: "biome", label: "Biome", hint: "all-in-one" }
     ],
-    initialValue: "oxfmt"
+    initialValue: presets?.formatter ?? "prettier"
   });
   if (p__namespace.isCancel(formatter)) {
     p__namespace.cancel("Operation cancelled.");
@@ -496,8 +531,15 @@ async function promptForMonorepoCustomization(name) {
     formatter
   };
 }
-async function promptForMonorepo(workspaceName) {
+async function promptForMonorepo(workspaceName, presets) {
   const defaultOptions = getDefaultMonorepoOptions(workspaceName);
+  if (presets) {
+    if (presets.linter) defaultOptions.linter = presets.linter;
+    if (presets.formatter) defaultOptions.formatter = presets.formatter;
+    if (presets.nodeVersion) defaultOptions.nodeVersion = presets.nodeVersion;
+    if (presets.pnpmManageVersions !== void 0)
+      defaultOptions.pnpmManageVersions = presets.pnpmManageVersions;
+  }
   p__namespace.note(
     formatMonorepoConfigSummary({
       name: defaultOptions.name,
@@ -505,24 +547,28 @@ async function promptForMonorepo(workspaceName) {
       packageManager: defaultOptions.packageManager ?? "pnpm",
       pnpmManageVersions: defaultOptions.pnpmManageVersions,
       linter: defaultOptions.linter ?? "oxlint",
-      formatter: defaultOptions.formatter ?? "oxfmt"
+      formatter: defaultOptions.formatter ?? "prettier"
     }),
     "Workspace Configuration"
   );
-  const proceed = await p__namespace.confirm({
+  const proceed = await p__namespace.select({
     message: "Proceed with these settings?",
-    initialValue: true
+    options: [
+      { value: "continue", label: "Yes, continue" },
+      { value: "customize", label: "No, customize settings" }
+    ],
+    initialValue: "continue"
   });
   if (p__namespace.isCancel(proceed)) {
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
-  if (proceed) {
+  if (proceed === "continue") {
     return defaultOptions;
   }
-  return promptForMonorepoCustomization(workspaceName);
+  return promptForMonorepoCustomization(workspaceName, presets);
 }
-async function promptForOptions(name) {
+async function promptForOptions(name, presets) {
   let projectName = name;
   if (!projectName) {
     const nameResult = await p__namespace.text({
@@ -546,30 +592,36 @@ async function promptForOptions(name) {
       { value: "library", label: "Library" },
       { value: "monorepo", label: "Monorepo" }
     ],
-    initialValue: "app"
+    initialValue: presets?.type ?? "app"
   });
   if (p__namespace.isCancel(projectType)) {
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
   if (projectType === "monorepo") {
-    return promptForMonorepo(projectName);
+    return promptForMonorepo(projectName, presets);
   }
-  return promptForPackageOptions(projectName, projectType);
+  return promptForPackageOptions(
+    projectName,
+    projectType,
+    void 0,
+    presets
+  );
 }
-function customTemplateToOptions(customTemplate, name, projectType) {
+function customTemplateToOptions(customTemplate, name, projectType, inheritedSettings) {
   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
+    packageManager: inheritedSettings?.packageManager ?? "pnpm",
+    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
+    nodeVersion: inheritedSettings?.nodeVersion ?? "latest",
+    linter: inheritedSettings?.linter ?? customTemplate.linter,
+    formatter: inheritedSettings?.formatter ?? customTemplate.formatter,
+    testing: customTemplate.testing,
+    configStrategy: customTemplate.configStrategy ?? getConfigStrategy()
   };
   if (baseTemplate === "r3f" && customTemplate.integrations) {
     const integrations = customTemplate.integrations;
@@ -591,7 +643,17 @@ function customTemplateToOptions(customTemplate, name, projectType) {
   }
   return base;
 }
-async function promptForPackageOptions(projectName, projectType, inheritedTooling) {
+function presetsToInheritedSettings(presets) {
+  if (!presets) return void 0;
+  return {
+    linter: presets.linter,
+    formatter: presets.formatter,
+    packageManager: presets.packageManager,
+    nodeVersion: presets.nodeVersion,
+    pnpmManageVersions: presets.pnpmManageVersions
+  };
+}
+async function promptForPackageOptions(projectName, projectType, inheritedSettings, presets) {
   const builtInOptions = [
     { value: "vanilla", label: "Vanilla" },
     { value: "react", label: "React" },
@@ -607,7 +669,7 @@ async function promptForPackageOptions(projectName, projectType, inheritedToolin
   const templateSelection = await p__namespace.select({
     message: "Select a template",
     options: allOptions,
-    initialValue: "vanilla"
+    initialValue: presets?.template ?? "vanilla"
   });
   if (p__namespace.isCancel(templateSelection)) {
     p__namespace.cancel("Operation cancelled.");
@@ -617,24 +679,27 @@ async function promptForPackageOptions(projectName, projectType, inheritedToolin
   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__namespace.note(formatConfigSummary(defaultOptions2), configTitle2);
-    const proceed2 = await p__namespace.confirm({
+    const defaultOptions2 = customTemplateToOptions(
+      customTemplate,
+      projectName,
+      projectType,
+      inheritedSettings
+    );
+    const configTitle2 = inheritedSettings ? `Template: ${customName} (using workspace settings)` : `Template: ${customName}`;
+    p__namespace.note(formatConfigSummary(defaultOptions2, inheritedSettings), configTitle2);
+    const proceed2 = await p__namespace.select({
       message: "Proceed with these settings?",
-      initialValue: true
+      options: [
+        { value: "continue", label: "Yes, continue" },
+        { value: "customize", label: "No, customize settings" }
+      ],
+      initialValue: "continue"
     });
     if (p__namespace.isCancel(proceed2)) {
       p__namespace.cancel("Operation cancelled.");
       process.exit(0);
     }
-    if (proceed2) {
+    if (proceed2 === "continue") {
       return defaultOptions2;
     }
     return promptForCustomization(
@@ -642,37 +707,48 @@ async function promptForPackageOptions(projectName, projectType, inheritedToolin
       projectName,
       projectType,
       customTemplate.integrations,
-      inheritedTooling
+      inheritedSettings
     );
   }
   const template = selection;
   const baseTemplate = index.getBaseTemplate(template);
   let integrations;
   if (baseTemplate === "r3f") {
-    integrations = await promptForR3fIntegrations();
+    integrations = await promptForR3fIntegrations(presets);
   }
   const defaultOptions = getDefaultOptions(
     template,
     projectName,
     projectType,
-    void 0,
+    presets?.bundler,
     integrations,
-    inheritedTooling
+    inheritedSettings ?? presetsToInheritedSettings(presets)
   );
-  const configTitle = inheritedTooling ? "Template Configuration (using workspace tooling)" : "Template Configuration";
-  p__namespace.note(formatConfigSummary(defaultOptions), configTitle);
-  const proceed = await p__namespace.confirm({
+  const configTitle = inheritedSettings ? "Template Configuration (using workspace settings)" : "Template Configuration";
+  p__namespace.note(formatConfigSummary(defaultOptions, inheritedSettings), configTitle);
+  const proceed = await p__namespace.select({
     message: "Proceed with these settings?",
-    initialValue: true
+    options: [
+      { value: "continue", label: "Yes, continue" },
+      { value: "customize", label: "No, customize settings" }
+    ],
+    initialValue: "continue"
   });
   if (p__namespace.isCancel(proceed)) {
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
-  if (proceed) {
+  if (proceed === "continue") {
     return defaultOptions;
   }
-  return promptForCustomization(template, projectName, projectType, integrations, inheritedTooling);
+  return promptForCustomization(
+    template,
+    projectName,
+    projectType,
+    integrations,
+    inheritedSettings,
+    presets
+  );
 }
 
 async function checkAnyExists(paths) {
@@ -720,8 +796,586 @@ async function validateWorkspace(monorepoRoot) {
   return { valid: errors.length === 0, errors };
 }
 
+async function detectCurrentConfig(root) {
+  let name = root.split(/[/\\]/).pop() ?? "workspace";
+  try {
+    const pkgPath = path.join(root, "package.json");
+    const content = await promises.readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    if (pkgJson.name) {
+      name = pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
+    }
+  } catch {
+  }
+  const tooling = await index.detectTooling(root);
+  return {
+    name,
+    linter: tooling.linter ?? "oxlint",
+    formatter: tooling.formatter ?? "prettier",
+    packageManager: "pnpm"
+  };
+}
+function generateExpectedFiles(config) {
+  const { name, linter, formatter, packageManager } = config;
+  const aiFilesMap = {};
+  index.generateAiFiles(aiFilesMap, {
+    name,
+    packageManager,
+    linter,
+    formatter,
+    isMonorepo: true,
+    platforms: index.ALL_AI_PLATFORMS
+  });
+  const vscodeFiles = {};
+  index.generateVscodeFiles(vscodeFiles, linter, formatter);
+  const configPackages = {};
+  index.generateTypescriptConfigPackage(configPackages);
+  if (linter === "oxlint") {
+    index.generateOxlintConfigPackage(configPackages);
+  } else if (linter === "eslint") {
+    index.generateEslintConfigPackage(configPackages);
+  }
+  if (formatter === "oxfmt") {
+    index.generateOxfmtConfigPackage(configPackages);
+  } else if (formatter === "prettier") {
+    index.generatePrettierConfigPackage(configPackages);
+  }
+  const workspaceConfig = {};
+  const rootConfig = {};
+  rootConfig[".gitignore"] = {
+    type: "text",
+    content: ["node_modules", "dist", "*.tsbuildinfo", ".DS_Store"].join("\n")
+  };
+  rootConfig[".gitattributes"] = {
+    type: "text",
+    content: `* text=auto eol=lf
+*.{cmd,[cC][mM][dD]} text eol=crlf
+*.{bat,[bB][aA][tT]} text eol=crlf
+`
+  };
+  if (linter === "biome" || formatter === "biome") {
+    const biomeConfig = {
+      $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+      vcs: {
+        enabled: true,
+        clientKind: "git",
+        useIgnoreFile: true
+      },
+      linter: {
+        enabled: linter === "biome",
+        rules: {
+          recommended: true
+        }
+      },
+      formatter: {
+        enabled: formatter === "biome"
+      }
+    };
+    rootConfig["biome.json"] = {
+      type: "text",
+      content: JSON.stringify(biomeConfig, null, 2)
+    };
+  }
+  return {
+    "ai-files": aiFilesMap,
+    vscode: vscodeFiles,
+    "config-packages": configPackages,
+    "workspace-config": workspaceConfig,
+    "root-config": rootConfig
+  };
+}
+async function fileExists$1(path) {
+  try {
+    await promises.access(path, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function compareWithDisk(expected, root) {
+  const categoryLabels = {
+    "ai-files": "AI Files",
+    vscode: "VS Code",
+    "config-packages": "Config Packages",
+    "workspace-config": "Workspace Config",
+    "root-config": "Root Config"
+  };
+  const categories = [];
+  for (const [category, files] of Object.entries(expected)) {
+    const changes = [];
+    for (const [filePath, file] of Object.entries(files)) {
+      if (file.type !== "text") continue;
+      const fullPath = path.join(root, filePath);
+      const newContent = file.content;
+      if (await fileExists$1(fullPath)) {
+        const currentContent = await promises.readFile(fullPath, "utf-8");
+        if (currentContent === newContent) {
+          changes.push({
+            path: filePath,
+            status: "unchanged",
+            currentContent,
+            newContent
+          });
+        } else {
+          changes.push({
+            path: filePath,
+            status: "modified",
+            currentContent,
+            newContent
+          });
+        }
+      } else {
+        changes.push({
+          path: filePath,
+          status: "added",
+          newContent
+        });
+      }
+    }
+    if (changes.length === 0) continue;
+    const hasUserModifications = changes.some((c) => c.status === "modified");
+    categories.push({
+      category,
+      label: categoryLabels[category],
+      changes,
+      hasUserModifications
+    });
+  }
+  return categories;
+}
+async function getWorkspaceConfigUpdates(root) {
+  const workspacePath = path.join(root, "pnpm-workspace.yaml");
+  const changes = [];
+  let currentContent = "";
+  let exists = false;
+  try {
+    currentContent = await promises.readFile(workspacePath, "utf-8");
+    exists = true;
+  } catch {
+  }
+  if (!exists) {
+    const newContent = `manage-package-manager-versions: true
+
+packages:
+  - ".config/*"
+  - "apps/*"
+  - "packages/*"
+
+onlyBuiltDependencies:
+  - esbuild
+`;
+    changes.push({
+      path: "pnpm-workspace.yaml",
+      status: "added",
+      newContent
+    });
+    return changes;
+  }
+  let updatedContent = currentContent;
+  let needsUpdate = false;
+  if (!currentContent.includes("manage-package-manager-versions")) {
+    updatedContent = `manage-package-manager-versions: true
+
+${updatedContent}`;
+    needsUpdate = true;
+  }
+  if (!currentContent.includes("onlyBuiltDependencies")) {
+    updatedContent = `${updatedContent.trimEnd()}
+
+onlyBuiltDependencies:
+  - esbuild
+`;
+    needsUpdate = true;
+  }
+  if (!currentContent.includes(".config/*") && !currentContent.includes('".config/*"')) {
+    const lines = updatedContent.split("\n");
+    const packagesIndex = lines.findIndex(
+      (line) => line.trim().startsWith("packages:")
+    );
+    if (packagesIndex !== -1) {
+      lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
+      updatedContent = lines.join("\n");
+      needsUpdate = true;
+    }
+  }
+  if (needsUpdate) {
+    changes.push({
+      path: "pnpm-workspace.yaml",
+      status: "modified",
+      currentContent,
+      newContent: updatedContent
+    });
+  } else {
+    changes.push({
+      path: "pnpm-workspace.yaml",
+      status: "unchanged",
+      currentContent,
+      newContent: currentContent
+    });
+  }
+  return changes;
+}
+async function applyUpdates(changes, root) {
+  for (const change of changes) {
+    if (change.status === "unchanged") continue;
+    const fullPath = path.join(root, change.path);
+    await promises.mkdir(path.dirname(fullPath), { recursive: true });
+    await promises.writeFile(fullPath, change.newContent);
+  }
+}
+function formatFileChange(change) {
+  const icon = change.status === "added" ? "+" : change.status === "modified" ? "~" : "=";
+  return `  ${icon} ${change.path}`;
+}
+const LINTER_DEPS = {
+  oxlint: "oxlint",
+  eslint: "eslint",
+  biome: "@biomejs/biome"
+};
+const FORMATTER_DEPS = {
+  oxfmt: "oxfmt",
+  prettier: "prettier",
+  biome: "@biomejs/biome"
+};
+const LINTER_CONFIG_PACKAGES = {
+  oxlint: "@config/oxlint",
+  eslint: "@config/eslint",
+  biome: null
+  // biome uses root biome.json
+};
+const FORMATTER_CONFIG_PACKAGES = {
+  oxfmt: "@config/oxfmt",
+  prettier: "@config/prettier",
+  biome: null
+  // biome uses root biome.json
+};
+function needsMigration(current, target) {
+  const linterChange = target.linter && target.linter !== current.linter;
+  const formatterChange = target.formatter && target.formatter !== current.formatter;
+  return linterChange || formatterChange || false;
+}
+async function getMigrationPlan(current, target, root) {
+  const toLinter = target.linter ?? current.linter;
+  const toFormatter = target.formatter ?? current.formatter;
+  const changes = [];
+  if (toLinter !== current.linter) {
+    if (current.linter !== "biome") {
+      changes.push({
+        type: "remove-dir",
+        path: `.config/${current.linter}`,
+        description: `Remove @config/${current.linter} package`
+      });
+    }
+    if (toLinter !== "biome") {
+      const files = {};
+      if (toLinter === "oxlint") {
+        index.generateOxlintConfigPackage(files);
+      } else if (toLinter === "eslint") {
+        index.generateEslintConfigPackage(files);
+      }
+      for (const [path, file] of Object.entries(files)) {
+        if (file.type === "text") {
+          changes.push({
+            type: "add-file",
+            path,
+            description: `Add ${path}`,
+            content: file.content
+          });
+        }
+      }
+    }
+    if (toLinter === "biome" && toFormatter === "biome") {
+      changes.push({
+        type: "add-file",
+        path: "biome.json",
+        description: "Add biome.json config",
+        content: JSON.stringify(
+          {
+            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
+            linter: { enabled: true, rules: { recommended: true } },
+            formatter: { enabled: true }
+          },
+          null,
+          2
+        )
+      });
+    } else if (toLinter === "biome" && toFormatter !== "biome") {
+      changes.push({
+        type: "add-file",
+        path: "biome.json",
+        description: "Add biome.json config (linter only)",
+        content: JSON.stringify(
+          {
+            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
+            linter: { enabled: true, rules: { recommended: true } },
+            formatter: { enabled: false }
+          },
+          null,
+          2
+        )
+      });
+    }
+    if (current.linter === "biome" && toLinter !== "biome" && current.formatter !== "biome" && toFormatter !== "biome") {
+      changes.push({
+        type: "remove-file",
+        path: "biome.json",
+        description: "Remove biome.json"
+      });
+    }
+  }
+  if (toFormatter !== current.formatter) {
+    const formatterSameAsLinter = current.formatter === current.linter;
+    if (current.formatter !== "biome" && !formatterSameAsLinter) {
+      changes.push({
+        type: "remove-dir",
+        path: `.config/${current.formatter}`,
+        description: `Remove @config/${current.formatter} package`
+      });
+    }
+    const newFormatterSameAsLinter = toFormatter === toLinter;
+    if (toFormatter !== "biome" && !newFormatterSameAsLinter) {
+      const files = {};
+      if (toFormatter === "oxfmt") {
+        index.generateOxfmtConfigPackage(files);
+      } else if (toFormatter === "prettier") {
+        index.generatePrettierConfigPackage(files);
+      }
+      for (const [path, file] of Object.entries(files)) {
+        if (file.type === "text") {
+          changes.push({
+            type: "add-file",
+            path,
+            description: `Add ${path}`,
+            content: file.content
+          });
+        }
+      }
+    }
+    if (toFormatter === "biome" && toLinter !== "biome") {
+      changes.push({
+        type: "add-file",
+        path: "biome.json",
+        description: "Add biome.json config (formatter only)",
+        content: JSON.stringify(
+          {
+            $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
+            linter: { enabled: false },
+            formatter: { enabled: true }
+          },
+          null,
+          2
+        )
+      });
+    }
+    if (current.formatter === "biome" && toFormatter !== "biome" && current.linter !== "biome" && toLinter !== "biome") {
+      changes.push({
+        type: "remove-file",
+        path: "biome.json",
+        description: "Remove biome.json"
+      });
+    }
+  }
+  changes.push({
+    type: "update-package-json",
+    path: "package.json",
+    description: "Update root package.json (devDependencies, scripts)"
+  });
+  const subPackageUpdates = await getSubPackageUpdates(
+    root,
+    current,
+    toLinter,
+    toFormatter
+  );
+  return {
+    fromLinter: current.linter,
+    toLinter,
+    fromFormatter: current.formatter,
+    toFormatter,
+    changes,
+    subPackageUpdates
+  };
+}
+async function getSubPackageUpdates(root, current, toLinter, toFormatter) {
+  const updates = [];
+  const workspacePath = path.join(root, "pnpm-workspace.yaml");
+  let workspaceContent;
+  try {
+    workspaceContent = await promises.readFile(workspacePath, "utf-8");
+  } catch {
+    return updates;
+  }
+  const packageGlobs = index.parseWorkspaceYamlContent(workspaceContent);
+  for (const glob of packageGlobs) {
+    if (glob.includes(".config")) continue;
+    const baseDir = glob.replace(/\/\*$/, "").replace(/^["']|["']$/g, "");
+    const basePath = path.join(root, baseDir);
+    try {
+      const entries = await promises.readdir(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pkgJsonPath = path.join(basePath, entry.name, "package.json");
+        try {
+          const content = await promises.readFile(pkgJsonPath, "utf-8");
+          const pkg = JSON.parse(content);
+          const devDeps = pkg.devDependencies ?? {};
+          const remove = [];
+          const add = [];
+          const oldLinterPkg = LINTER_CONFIG_PACKAGES[current.linter];
+          const newLinterPkg = LINTER_CONFIG_PACKAGES[toLinter];
+          if (oldLinterPkg && oldLinterPkg !== newLinterPkg && devDeps[oldLinterPkg]) {
+            remove.push(oldLinterPkg);
+          }
+          if (newLinterPkg && newLinterPkg !== oldLinterPkg && oldLinterPkg && devDeps[oldLinterPkg]) {
+            add.push(newLinterPkg);
+          }
+          if (current.formatter !== current.linter) {
+            const oldFormatterPkg = FORMATTER_CONFIG_PACKAGES[current.formatter];
+            const newFormatterPkg = FORMATTER_CONFIG_PACKAGES[toFormatter];
+            if (oldFormatterPkg && oldFormatterPkg !== newFormatterPkg && devDeps[oldFormatterPkg]) {
+              remove.push(oldFormatterPkg);
+            }
+            if (newFormatterPkg && newFormatterPkg !== oldFormatterPkg && oldFormatterPkg && devDeps[oldFormatterPkg]) {
+              add.push(newFormatterPkg);
+            }
+          }
+          if (remove.length > 0 || add.length > 0) {
+            updates.push({
+              path: path.join(baseDir, entry.name, "package.json"),
+              remove,
+              add
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return updates;
+}
+async function applyMigration(plan, root) {
+  for (const change of plan.changes) {
+    if (change.type === "remove-dir") {
+      const fullPath = path.join(root, change.path);
+      try {
+        await promises.rm(fullPath, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  for (const change of plan.changes) {
+    if (change.type === "remove-file") {
+      const fullPath = path.join(root, change.path);
+      try {
+        await promises.rm(fullPath);
+      } catch {
+      }
+    }
+  }
+  for (const change of plan.changes) {
+    if (change.type === "add-file" && change.content) {
+      const fullPath = path.join(root, change.path);
+      await promises.mkdir(path.dirname(fullPath), { recursive: true });
+      await promises.writeFile(fullPath, change.content);
+    }
+  }
+  await updateRootPackageJson(root, plan);
+  for (const update of plan.subPackageUpdates) {
+    await updateSubPackageJson(root, update);
+  }
+}
+async function updateRootPackageJson(root, plan) {
+  const pkgPath = path.join(root, "package.json");
+  const content = await promises.readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  const oldLinterDep = LINTER_DEPS[plan.fromLinter];
+  delete devDeps[oldLinterDep];
+  if (plan.fromFormatter !== plan.fromLinter) {
+    const oldFormatterDep = FORMATTER_DEPS[plan.fromFormatter];
+    delete devDeps[oldFormatterDep];
+  }
+  const newLinterDep = LINTER_DEPS[plan.toLinter];
+  if (plan.toLinter === "oxlint") {
+    devDeps[newLinterDep] = "^1.36.0";
+  } else if (plan.toLinter === "eslint") {
+    devDeps[newLinterDep] = "^9.17.0";
+  } else if (plan.toLinter === "biome") {
+    devDeps[newLinterDep] = "^1.9.4";
+  }
+  if (plan.toFormatter !== plan.toLinter) {
+    const newFormatterDep = FORMATTER_DEPS[plan.toFormatter];
+    if (plan.toFormatter === "oxfmt") {
+      devDeps[newFormatterDep] = "^0.21.0";
+    } else if (plan.toFormatter === "prettier") {
+      devDeps[newFormatterDep] = "^3.4.2";
+    } else if (plan.toFormatter === "biome") {
+      devDeps[newFormatterDep] = "^1.9.4";
+    }
+  }
+  pkg.devDependencies = Object.fromEntries(
+    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
+  );
+  const scripts = pkg.scripts ?? {};
+  if (plan.toLinter === "oxlint") {
+    scripts.lint = "oxlint .";
+  } else if (plan.toLinter === "eslint") {
+    scripts.lint = "eslint .";
+  } else if (plan.toLinter === "biome") {
+    scripts.lint = "biome check .";
+  }
+  if (plan.toFormatter === "oxfmt") {
+    scripts.format = "oxfmt .";
+  } else if (plan.toFormatter === "prettier") {
+    scripts.format = "prettier --write .";
+  } else if (plan.toFormatter === "biome") {
+    scripts.format = "biome format . --write";
+  }
+  pkg.scripts = scripts;
+  await promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+async function updateSubPackageJson(root, update) {
+  const pkgPath = path.join(root, update.path);
+  const content = await promises.readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  for (const dep of update.remove) {
+    delete devDeps[dep];
+  }
+  for (const dep of update.add) {
+    devDeps[dep] = "workspace:*";
+  }
+  pkg.devDependencies = Object.fromEntries(
+    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
+  );
+  await promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+function formatMigrationChange(change) {
+  const icon = change.type === "remove-dir" || change.type === "remove-file" ? "-" : change.type === "add-file" ? "+" : "~";
+  return `  ${icon} ${change.description}`;
+}
+
 const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
 const pkg = require$1("../package.json");
+const META_OPTIONS = [
+  "clearConfig",
+  "configPath",
+  "check",
+  "fix",
+  "update",
+  "yes",
+  "workspace",
+  "path",
+  "dir"
+];
+function hasConfigOptions(options) {
+  return Object.keys(options).some(
+    (key) => !META_OPTIONS.includes(key)
+  );
+}
 async function fileExists(path) {
   try {
     await promises.access(path, fs.constants.F_OK);
@@ -730,6 +1384,50 @@ async function fileExists(path) {
     return false;
   }
 }
+async function promptForAiPlatforms(isNonInteractive) {
+  const savedPlatforms = getAiPlatforms();
+  if (isNonInteractive) {
+    return savedPlatforms ?? index.ALL_AI_PLATFORMS;
+  }
+  if (savedPlatforms && savedPlatforms.length > 0) {
+    const savedLabels = savedPlatforms.map((plat) => index.AI_PLATFORM_LABELS[plat]).join(", ");
+    const useDefault = await p__namespace.confirm({
+      message: `Add AI rules? ${color__default.dim(`(${savedLabels})`)}`,
+      initialValue: true
+    });
+    if (p__namespace.isCancel(useDefault)) {
+      return [];
+    }
+    if (useDefault) {
+      return savedPlatforms;
+    }
+  }
+  const selected = await p__namespace.multiselect({
+    message: "Add AI rules?",
+    options: index.ALL_AI_PLATFORMS.map((platform) => ({
+      value: platform,
+      label: index.AI_PLATFORM_LABELS[platform],
+      hint: index.AI_PLATFORM_HINTS[platform]
+    })),
+    initialValues: [],
+    required: false
+  });
+  if (p__namespace.isCancel(selected)) {
+    return [];
+  }
+  const platforms = selected;
+  if (platforms.length === 0) {
+    return [];
+  }
+  const saveChoice = await p__namespace.confirm({
+    message: "Save selection for future projects?",
+    initialValue: true
+  });
+  if (!p__namespace.isCancel(saveChoice) && saveChoice) {
+    setAiPlatforms(platforms);
+  }
+  return platforms;
+}
 async function writeGeneratedFiles(basePath, files) {
   const filePaths = Object.keys(files).sort();
   for (const filePath of filePaths) {
@@ -774,15 +1472,39 @@ async function parseWorkspaceDirectories(monorepoRoot) {
     return [];
   }
 }
-async function detectWorkspaceTooling(monorepoRoot) {
+async function detectWorkspaceSettings(monorepoRoot) {
   try {
+    const tooling = await index.detectTooling(monorepoRoot);
     const pkgPath = path.join(monorepoRoot, "package.json");
     const content = await promises.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 };
+    let packageManager;
+    if (pkgJson.packageManager) {
+      packageManager = pkgJson.packageManager.split("@")[0];
+    }
+    let nodeVersion;
+    if (pkgJson.engines?.node) {
+      const match = pkgJson.engines.node.match(/(\d+)/);
+      if (match) {
+        nodeVersion = match[1];
+      }
+    }
+    let pnpmManageVersions;
+    try {
+      const workspaceFile = path.join(monorepoRoot, "pnpm-workspace.yaml");
+      const workspaceContent = await promises.readFile(workspaceFile, "utf-8");
+      pnpmManageVersions = workspaceContent.includes(
+        "manage-package-manager-versions: true"
+      );
+    } catch {
+    }
+    return {
+      linter: tooling.linter,
+      formatter: tooling.formatter,
+      packageManager,
+      nodeVersion,
+      pnpmManageVersions
+    };
   } catch {
     return {};
   }
@@ -821,29 +1543,26 @@ async function getMonorepoScope(monorepoRoot) {
 }
 async function getWorkspacePackages(monorepoRoot) {
   const packagesDir = path.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 = path.join(packagesDir, entry.name, "package.json");
-          const content = await promises.readFile(pkgJsonPath, "utf-8");
-          const pkgJson = JSON.parse(content);
-          if (pkgJson.name) {
-            packages.push({
-              name: pkgJson.name,
-              path: `packages/${entry.name}`
-            });
-          }
-        } catch {
-        }
+      if (!entry.isDirectory()) continue;
+      try {
+        const content = await promises.readFile(
+          path.join(packagesDir, entry.name, "package.json"),
+          "utf-8"
+        );
+        const pkg2 = JSON.parse(content);
+        if (pkg2.name) names.push(pkg2.name);
+      } catch {
       }
     }
+    return names;
   } catch {
+    return [];
   }
-  return packages;
 }
 async function ensureConfigInWorkspace(monorepoRoot) {
   const workspacePath = path.join(monorepoRoot, "pnpm-workspace.yaml");
@@ -1011,7 +1730,7 @@ Or in \`package.json\`:
     content: existingContent
   };
 }
-async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedTooling, scope) {
+async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedSettings, scope) {
   const workspaceDirectories = await parseWorkspaceDirectories(monorepoRoot);
   const defaultDirectories = ["apps", "packages"];
   const hasCustomDirectories = workspaceDirectories.length > 0 && !workspaceDirectories.every((dir) => defaultDirectories.includes(dir));
@@ -1047,7 +1766,7 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedT
   const packageOptions = await promptForPackageOptions(
     scopedName,
     packageType,
-    inheritedTooling
+    inheritedSettings
   );
   let targetDir = defaultDir;
   if (hasCustomDirectories && workspaceDirectories.length > 0) {
@@ -1125,7 +1844,7 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedT
       })
     );
   }
-  const formatter = packageOptions.formatter ?? "oxfmt";
+  const formatter = packageOptions.formatter ?? "prettier";
   if (formatter === "prettier") {
     versionPromises.push(
       index.getLatestNpmVersion("prettier", "3.4.2").then((v) => {
@@ -1147,20 +1866,15 @@ 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__namespace.multiselect({
-        message: "Add workspace dependencies?",
-        options: workspacePackages.map((pkgInfo) => ({
-          value: pkgInfo.name,
-          label: pkgInfo.name.replace(/^@[^/]+\//, "")
-        })),
-        required: false
-      });
-      if (!p__namespace.isCancel(selectedDeps) && selectedDeps.length > 0) {
-        packageOptions.workspaceDependencies = selectedDeps;
-      }
+  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
+  if (workspacePackages.length > 0) {
+    const selectedDeps = await p__namespace.multiselect({
+      message: "Add workspace dependencies?",
+      options: workspacePackages.map((name) => ({ value: name, label: name })),
+      required: false
+    });
+    if (!p__namespace.isCancel(selectedDeps) && selectedDeps.length > 0) {
+      packageOptions.workspaceDependencies = selectedDeps;
     }
   }
   const outputPath = path.join(monorepoRoot, relativePkgPath);
@@ -1285,11 +1999,11 @@ async function handleFixCommand(options) {
     console.log(color__default.dim(`  \u2022 ${error}`));
   }
   console.log();
-  const tooling = await detectWorkspaceTooling(monorepoRoot);
+  const tooling = await detectWorkspaceSettings(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;
+  const detectedFormatter = tooling.formatter ?? existingConfigs.formatter ?? "prettier";
+  const isNonInteractive = Boolean(options.linter && options.formatter);
   let linter;
   let formatter;
   if (isNonInteractive) {
@@ -1467,85 +2181,346 @@ async function handleFixCommand(options) {
         console.log(color__default.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$1] of Object.entries(aiFilePaths)) {
-      if (await fileExists(path.join(monorepoRoot, path$1))) {
-        existingAiFiles.push(choice);
+    const aiRulesExist = await fileExists(
+      path.join(monorepoRoot, ".ai/workspace.md")
+    );
+    if (!aiRulesExist) {
+      const platforms = await promptForAiPlatforms(isNonInteractive);
+      if (platforms.length > 0) {
+        const scope = await getMonorepoScope(monorepoRoot);
+        const aiFilesOutput = {};
+        index.generateAiFiles(aiFilesOutput, {
+          name: scope,
+          packageManager: "pnpm",
+          linter,
+          formatter,
+          isMonorepo: true,
+          platforms
+        });
+        for (const [filePath, file] of Object.entries(aiFilesOutput)) {
+          const fullPath = path.join(monorepoRoot, filePath);
+          await promises.mkdir(path.dirname(fullPath), { recursive: true });
+          await promises.writeFile(fullPath, file.content);
+          console.log(color__default.dim(`  Generated ${filePath}`));
+        }
       }
     }
-    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)
+    process.exit(0);
+  } catch (error) {
+    spinner.stop(color__default.red("\u2717") + " Failed to fix workspace");
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function handleMigration(config, target, root, options) {
+  const plan = await getMigrationPlan(config, target, root);
+  console.log(color__default.cyan("Migration:"));
+  if (plan.fromLinter !== plan.toLinter) {
+    console.log(
+      `  Linter: ${color__default.dim(plan.fromLinter)} \u2192 ${color__default.green(plan.toLinter)}`
+    );
+  }
+  if (plan.fromFormatter !== plan.toFormatter) {
+    console.log(
+      `  Formatter: ${color__default.dim(plan.fromFormatter)} \u2192 ${color__default.green(
+        plan.toFormatter
+      )}`
+    );
+  }
+  console.log();
+  console.log(color__default.cyan("Changes:"));
+  for (const change of plan.changes) {
+    console.log(formatMigrationChange(change));
+  }
+  if (plan.subPackageUpdates.length > 0) {
+    console.log();
+    console.log(color__default.cyan(`Sub-packages (${plan.subPackageUpdates.length}):`));
+    for (const update of plan.subPackageUpdates) {
+      const changes = [
+        ...update.remove.map((d) => `-${d}`),
+        ...update.add.map((d) => `+${d}`)
+      ].join(", ");
+      console.log(`  ~ ${update.path} (${changes})`);
+    }
+  }
+  console.log();
+  if (!options.yes) {
+    const confirm = await p__namespace.confirm({
+      message: "Apply migration?",
+      initialValue: true
+    });
+    if (p__namespace.isCancel(confirm) || !confirm) {
+      console.log(color__default.dim("  Migration cancelled"));
+      process.exit(0);
+    }
+  }
+  await applyMigration(plan, root);
+  const aiWorkspacePath = path.join(root, ".ai/workspace.md");
+  const aiRulesExist = await fileExists(aiWorkspacePath);
+  if (aiRulesExist) {
+    console.log();
+    console.log(color__default.cyan("Updating AI rules..."));
+    const scope = await getMonorepoScope(root);
+    const existingPlatforms = [];
+    if (await fileExists(path.join(root, "AGENTS.md"))) {
+      existingPlatforms.push("agents");
+    }
+    if (await fileExists(path.join(root, "CLAUDE.md"))) {
+      existingPlatforms.push("claude");
+    }
+    const aiFilesOutput = {};
+    index.generateAiFiles(aiFilesOutput, {
+      name: scope,
+      packageManager: "pnpm",
+      linter: plan.toLinter,
+      formatter: plan.toFormatter,
+      isMonorepo: true,
+      platforms: existingPlatforms.length > 0 ? existingPlatforms : ["agents"]
+    });
+    for (const [filePath, file] of Object.entries(aiFilesOutput)) {
+      const fullPath = path.join(root, filePath);
+      await promises.mkdir(path.dirname(fullPath), { recursive: true });
+      await promises.writeFile(fullPath, file.content);
+      console.log(color__default.dim(`  ${filePath}`));
+    }
+  }
+  console.log();
+  console.log(
+    color__default.green("\u2713") + ` Migrated to ${plan.toLinter}/${plan.toFormatter}`
+  );
+  console.log(color__default.dim("  Run `pnpm install` to update dependencies"));
+  process.exit(0);
+}
+async function handleUpdateCommand(options) {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color__default.red("\u2717") + " Not a monorepo workspace");
+    console.log(color__default.dim("  --update only supports pnpm monorepos"));
+    process.exit(1);
+  }
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (!valid) {
+    console.log(color__default.yellow("!") + " Workspace has issues:");
+    for (const error of errors) {
+      console.log(color__default.dim(`  \u2022 ${error}`));
+    }
+    console.log();
+    const shouldFix = options.yes || await p__namespace.confirm({
+      message: "Run fix first to resolve these issues?",
+      initialValue: true
+    });
+    if (p__namespace.isCancel(shouldFix) || !shouldFix) {
+      console.log(
+        color__default.dim("  Run `pnpm create krispya --fix` to fix manually")
       );
-      if (availableSaved.length > 0) {
-        const savedLabels = availableSaved.map((f) => aiFilePaths[f]).join(", ");
-        const useDefault = await p__namespace.confirm({
-          message: `Generate AI instruction files? ${color__default.dim(
-            `(${savedLabels})`
-          )}`,
+      process.exit(1);
+    }
+    const preFixConfig = await detectCurrentConfig(monorepoRoot);
+    const fixOptions = {
+      ...options,
+      linter: options.linter ?? preFixConfig.linter,
+      formatter: options.formatter ?? preFixConfig.formatter
+    };
+    await handleFixCommand(fixOptions);
+  }
+  const config = await detectCurrentConfig(monorepoRoot);
+  const targetLinter = options.linter;
+  const targetFormatter = options.formatter;
+  const migrationTarget = { linter: targetLinter, formatter: targetFormatter };
+  if (needsMigration(config, migrationTarget)) {
+    await handleMigration(config, migrationTarget, monorepoRoot, options);
+    return;
+  }
+  console.log(
+    color__default.cyan("Checking for updates...") + color__default.dim(` (${config.linter}/${config.formatter})`)
+  );
+  console.log();
+  const expected = generateExpectedFiles(config);
+  const categories = await compareWithDisk(expected, monorepoRoot);
+  const workspaceConfigChanges = await getWorkspaceConfigUpdates(monorepoRoot);
+  const workspaceCategory = {
+    category: "workspace-config",
+    label: "Workspace Config",
+    changes: workspaceConfigChanges,
+    hasUserModifications: workspaceConfigChanges.some(
+      (c) => c.status === "modified"
+    )
+  };
+  const allCategories = categories.filter(
+    (c) => c.category !== "workspace-config"
+  );
+  if (workspaceConfigChanges.length > 0) {
+    const configPkgIndex = allCategories.findIndex(
+      (c) => c.category === "config-packages"
+    );
+    if (configPkgIndex !== -1) {
+      allCategories.splice(configPkgIndex + 1, 0, workspaceCategory);
+    } else {
+      allCategories.push(workspaceCategory);
+    }
+  }
+  let updatedCount = 0;
+  let skippedCount = 0;
+  for (const category of allCategories) {
+    const newChanges = category.changes.filter((c) => c.status === "added");
+    const modifiedChanges = category.changes.filter(
+      (c) => c.status === "modified"
+    );
+    const hasNew = newChanges.length > 0;
+    const hasModified = modifiedChanges.length > 0;
+    const hasChanges = hasNew || hasModified;
+    if (!hasChanges) {
+      console.log(color__default.green("\u2713") + ` ${category.label}: Up to date`);
+      continue;
+    }
+    if (category.category === "ai-files") {
+      if (hasNew) {
+        console.log(color__default.cyan(category.label + ":"));
+        console.log(
+          color__default.dim(`  ${newChanges.length} AI file(s) can be added`)
+        );
+        console.log();
+        const applyAi = options.yes ? true : await p__namespace.confirm({
+          message: "Add AI rules?",
           initialValue: true
         });
-        if (!p__namespace.isCancel(useDefault) && useDefault) {
-          selectedAiFiles = availableSaved;
+        if (!p__namespace.isCancel(applyAi) && applyAi) {
+          await applyUpdates(newChanges, monorepoRoot);
+          console.log(
+            color__default.green("\u2713") + ` Added ${newChanges.length} AI file(s)`
+          );
+          updatedCount++;
+        } else {
+          console.log(color__default.dim(`  Skipped ${category.label}`));
+          skippedCount++;
         }
       }
-    } else {
-      const aiFilesChoice = await p__namespace.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"
+      if (hasModified) {
+        console.log(color__default.cyan("AI Files (existing):"));
+        for (const change of modifiedChanges) {
+          console.log(formatFileChange(change));
+        }
+        console.log();
+        if (options.yes) {
+          console.log(color__default.dim("  (--yes mode: keeping existing AI files)"));
+        } else {
+          const updateExisting = await p__namespace.confirm({
+            message: "Update existing AI files to latest template?",
+            initialValue: false
+          });
+          if (!p__namespace.isCancel(updateExisting) && updateExisting) {
+            await applyUpdates(modifiedChanges, monorepoRoot);
+            console.log(color__default.green("\u2713") + " Updated existing AI files");
+          }
+        }
+      }
+      console.log();
+      continue;
+    }
+    let changesToApply = [];
+    if (options.yes) {
+      console.log(color__default.cyan(category.label + ":"));
+      for (const change of [...newChanges, ...modifiedChanges]) {
+        console.log(formatFileChange(change));
+      }
+      console.log();
+      if (category.category === "workspace-config") {
+        changesToApply = [...newChanges, ...modifiedChanges];
+        if (changesToApply.length > 0) {
+          console.log(color__default.dim("  (--yes mode: applying merge updates)"));
+        }
+      } else {
+        changesToApply = newChanges;
+        if (newChanges.length > 0) {
+          console.log(color__default.dim("  (--yes mode: adding new files only)"));
+        }
+      }
+    } else if (hasNew && hasModified) {
+      const allChanges = [...newChanges, ...modifiedChanges];
+      const selectedFiles = await p__namespace.multiselect({
+        message: `${category.label} (+ new, ~ changed)`,
+        options: allChanges.map((change) => ({
+          value: change.path,
+          label: change.status === "added" ? `+ ${change.path}` : `~ ${change.path}`
         })),
+        initialValues: newChanges.map((c) => c.path),
+        // Pre-select new files
         required: false
       });
-      if (!p__namespace.isCancel(aiFilesChoice) && aiFilesChoice.length > 0) {
-        selectedAiFiles = aiFilesChoice;
-        const saveChoice = await p__namespace.confirm({
-          message: "Save as default for future?",
-          initialValue: true
-        });
-        if (!p__namespace.isCancel(saveChoice) && saveChoice) {
-          setAiFiles(selectedAiFiles);
-        }
+      if (p__namespace.isCancel(selectedFiles)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
       }
-    }
-    if (selectedAiFiles.length > 0) {
-      const scope = await getMonorepoScope(monorepoRoot);
-      const aiFilesOutput = {};
-      index.generateAiFiles(aiFilesOutput, {
-        name: scope,
-        packageManager: "pnpm",
-        linter,
-        formatter,
-        aiFiles: selectedAiFiles
+      if (selectedFiles.length > 0) {
+        changesToApply = allChanges.filter(
+          (c) => selectedFiles.includes(c.path)
+        );
+      }
+    } else if (hasNew) {
+      console.log(color__default.cyan(category.label + ":"));
+      for (const change of newChanges) {
+        console.log(formatFileChange(change));
+      }
+      console.log();
+      const shouldAdd = await p__namespace.confirm({
+        message: `Add ${newChanges.length} new file(s)?`,
+        initialValue: true
       });
-      for (const [filePath, file] of Object.entries(aiFilesOutput)) {
-        const fullPath = path.join(monorepoRoot, filePath);
-        await promises.mkdir(path.dirname(fullPath), { recursive: true });
-        await promises.writeFile(fullPath, file.content);
-        console.log(color__default.dim(`  Generated ${filePath}`));
+      if (p__namespace.isCancel(shouldAdd)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (shouldAdd) {
+        changesToApply = newChanges;
+      }
+    } else if (hasModified) {
+      console.log(color__default.cyan(category.label + ":"));
+      for (const change of modifiedChanges) {
+        console.log(formatFileChange(change));
+      }
+      console.log();
+      const shouldUpdate = await p__namespace.confirm({
+        message: `Update ${modifiedChanges.length} file(s)? (will overwrite)`,
+        initialValue: false
+      });
+      if (p__namespace.isCancel(shouldUpdate)) {
+        p__namespace.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      if (shouldUpdate) {
+        changesToApply = modifiedChanges;
       }
     }
-    process.exit(0);
-  } catch (error) {
-    spinner.stop(color__default.red("\u2717") + " Failed to fix workspace");
-    console.error(error);
-    process.exit(1);
+    if (changesToApply.length > 0) {
+      await applyUpdates(changesToApply, monorepoRoot);
+      const addedCount = changesToApply.filter(
+        (c) => c.status === "added"
+      ).length;
+      const updatedFilesCount = changesToApply.filter(
+        (c) => c.status === "modified"
+      ).length;
+      const parts = [];
+      if (addedCount > 0) parts.push(`added ${addedCount}`);
+      if (updatedFilesCount > 0) parts.push(`updated ${updatedFilesCount}`);
+      console.log(color__default.green("\u2713") + ` ${category.label}: ${parts.join(", ")}`);
+      updatedCount++;
+    } else {
+      console.log(color__default.dim(`  Skipped ${category.label}`));
+      skippedCount++;
+    }
+    console.log();
   }
+  if (updatedCount === 0 && skippedCount === 0) {
+    console.log(color__default.green("\u2713") + " Everything is up to date!");
+  } else if (updatedCount > 0) {
+    console.log(
+      color__default.green("\u2713") + ` Updated ${updatedCount} ${updatedCount === 1 ? "category" : "categories"}`
+    );
+    if (skippedCount > 0) {
+      console.log(color__default.dim(`  Skipped ${skippedCount}`));
+    }
+  }
+  process.exit(0);
 }
 async function handleWorkspaceCommand(name, options) {
   const monorepoRoot = await detectMonorepoRoot();
@@ -1567,7 +2542,7 @@ async function handleWorkspaceCommand(name, options) {
     process.exit(1);
   }
   const scope = await getMonorepoScope(monorepoRoot);
-  const inheritedTooling = await detectWorkspaceTooling(monorepoRoot);
+  const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
   const projectType = options.type ?? "app";
   const defaultDir = projectType === "library" ? "packages" : "apps";
   const targetDir = options.dir ?? defaultDir;
@@ -1593,8 +2568,11 @@ async function handleWorkspaceCommand(name, options) {
       })
     );
   }
-  const linter = inheritedTooling.linter ?? options.linter ?? "oxlint";
-  const formatter = inheritedTooling.formatter ?? options.formatter ?? "oxfmt";
+  const linter = inheritedSettings.linter ?? options.linter ?? "oxlint";
+  const formatter = inheritedSettings.formatter ?? options.formatter ?? "prettier";
+  const packageManager = inheritedSettings.packageManager ?? "pnpm";
+  const nodeVersion = inheritedSettings.nodeVersion ?? "latest";
+  const pnpmManageVersions = inheritedSettings.pnpmManageVersions ?? true;
   await Promise.all(versionPromises);
   const relativePkgPath = path.join(targetDir, name);
   const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
@@ -1605,6 +2583,9 @@ async function handleWorkspaceCommand(name, options) {
     template,
     linter,
     formatter,
+    packageManager,
+    nodeVersion,
+    pnpmManageVersions,
     workspaceRoot,
     versions,
     ...baseTemplate === "r3f" && {
@@ -1638,7 +2619,7 @@ async function handleWorkspaceCommand(name, options) {
     process.exit(1);
   }
 }
-async function handleMonorepoCreation(generateOptions) {
+async function handleMonorepoCreation(generateOptions, isNonInteractive) {
   const { generateMonorepo } = await import('./chunks/index.cjs').then(function (n) { return n.monorepo; });
   const packageManager = generateOptions.packageManager || "pnpm";
   if (packageManager === "pnpm") {
@@ -1652,55 +2633,7 @@ async function handleMonorepoCreation(generateOptions) {
   if (nodeVersion === "latest") {
     generateOptions.nodeVersion = await index.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__namespace.confirm({
-      message: `Generate AI instruction files? ${color__default.dim(
-        `(${savedLabels})`
-      )}`,
-      initialValue: true
-    });
-    if (!p__namespace.isCancel(useDefault) && useDefault) {
-      selectedAiFiles = savedAiFiles;
-    }
-  } else {
-    const aiFilesChoice = await p__namespace.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__namespace.isCancel(aiFilesChoice) && aiFilesChoice.length > 0) {
-      selectedAiFiles = aiFilesChoice;
-      const saveChoice = await p__namespace.confirm({
-        message: "Save as default for future monorepos?",
-        initialValue: true
-      });
-      if (!p__namespace.isCancel(saveChoice) && saveChoice) {
-        setAiFiles(selectedAiFiles);
-      }
-    }
-  }
+  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
   const projectPath = path.join(process$1.cwd(), generateOptions.name);
   const spinner = p__namespace.spinner();
   spinner.start("Creating monorepo workspace...");
@@ -1708,12 +2641,12 @@ async function handleMonorepoCreation(generateOptions) {
     const { files } = generateMonorepo({
       name: generateOptions.name,
       linter: generateOptions.linter ?? "oxlint",
-      formatter: generateOptions.formatter ?? "oxfmt",
+      formatter: generateOptions.formatter ?? "prettier",
       packageManager,
       pnpmVersion: generateOptions.pnpmVersion,
       pnpmManageVersions: generateOptions.pnpmManageVersions,
       nodeVersion: generateOptions.nodeVersion,
-      aiFiles: selectedAiFiles.length > 0 ? selectedAiFiles : void 0
+      aiPlatforms: aiPlatforms.length > 0 ? aiPlatforms : void 0
     });
     const filePaths = Object.keys(files).sort();
     for (const filePath of filePaths) {
@@ -1725,9 +2658,15 @@ async function handleMonorepoCreation(generateOptions) {
       }
     }
     spinner.stop(color__default.green.inverse(" \u2713 Monorepo workspace created! "));
-    const newMonorepoTooling = {
+    if (isNonInteractive) {
+      process.exit(0);
+    }
+    const newWorkspaceSettings = {
       linter: generateOptions.linter,
-      formatter: generateOptions.formatter
+      formatter: generateOptions.formatter,
+      packageManager,
+      nodeVersion: generateOptions.nodeVersion,
+      pnpmManageVersions: generateOptions.pnpmManageVersions
     };
     const scope = generateOptions.name;
     let addMore = true;
@@ -1735,7 +2674,7 @@ async function handleMonorepoCreation(generateOptions) {
       addMore = await createPackageInWorkspace(
         projectPath,
         packageManager,
-        newMonorepoTooling,
+        newWorkspaceSettings,
         scope
       );
     }
@@ -1754,10 +2693,14 @@ async function handleMonorepoCreation(generateOptions) {
     process.exit(1);
   }
 }
-async function handleStandaloneProjectCreation(generateOptions) {
+async function handleStandaloneProjectCreation(generateOptions, isNonInteractive) {
   const base = generateOptions.template ? index.getBaseTemplate(generateOptions.template) : "vanilla";
   const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
   generateOptions.name ??= defaultFallbackName;
+  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
+  if (aiPlatforms.length > 0) {
+    generateOptions.aiPlatforms = aiPlatforms;
+  }
   const packageManager = generateOptions.packageManager || "pnpm";
   if (packageManager === "pnpm") {
     generateOptions.pnpmVersion = await index.getLatestPnpmVersion();
@@ -1808,7 +2751,7 @@ async function handleStandaloneProjectCreation(generateOptions) {
       })
     );
   }
-  const formatter = generateOptions.formatter ?? "oxfmt";
+  const formatter = generateOptions.formatter ?? "prettier";
   if (formatter === "prettier") {
     versionPromises.push(
       index.getLatestNpmVersion("prettier", "3.4.2").then((v) => {
@@ -1837,6 +2780,9 @@ async function handleStandaloneProjectCreation(generateOptions) {
     const files = index.generate(generateOptions);
     await writeGeneratedFiles(projectPath, files);
     spinner.stop(color__default.green.inverse(" \u2713 Project created! "));
+    if (isNonInteractive) {
+      process.exit(0);
+    }
     const nextSteps = isLibrary ? [
       `cd ${generateOptions.name}`,
       `${packageManager} install`,
@@ -1869,21 +2815,23 @@ async function handleInteractiveMonorepoMode(monorepoRoot) {
     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}`
+    const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
+    const hasSettings = Object.values(inheritedSettings).some(Boolean);
+    if (hasSettings) {
+      const settingsInfo = [
+        inheritedSettings.linter && `linter: ${inheritedSettings.linter}`,
+        inheritedSettings.formatter && `formatter: ${inheritedSettings.formatter}`,
+        inheritedSettings.packageManager && `pm: ${inheritedSettings.packageManager}`
       ].filter(Boolean).join(", ");
-      p__namespace.log.info(`Using workspace tooling (${toolingInfo})`);
+      p__namespace.log.info(`Using workspace settings (${settingsInfo})`);
     }
     const scope = await getMonorepoScope(monorepoRoot);
     let addMore = true;
     while (addMore) {
       addMore = await createPackageInWorkspace(
         monorepoRoot,
-        "pnpm",
-        inheritedTooling,
+        inheritedSettings.packageManager ?? "pnpm",
+        inheritedSettings,
         scope
       );
     }
@@ -1910,7 +2858,7 @@ async function main() {
     "linter: eslint, oxlint, or biome (default: oxlint)"
   ).option(
     "--formatter <type>",
-    "formatter: prettier, oxfmt, or biome (default: oxfmt)"
+    "formatter: prettier, oxfmt, or biome (default: prettier)"
   ).option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option(
     "--package-manager <manager>",
     "specify package manager (e.g. npm, yarn, pnpm)"
@@ -1932,7 +2880,7 @@ async function main() {
   ).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(
+  ).option("--fix", "Fix monorepo by generating missing .config packages").option("--update", "Update monorepo workspace to latest configuration").option("-y, --yes", "Non-interactive mode - accept all prompts").option(
     "--path <directory>",
     "Run in specified directory instead of current working directory"
   ).action(async (name, options) => {
@@ -1971,6 +2919,12 @@ async function main() {
         case "--fix":
           options.fix = true;
           break;
+        case "--update":
+          options.update = true;
+          break;
+        case "--yes":
+          options.yes = true;
+          break;
         default:
           console.error(color__default.red(`Unknown option: ${name}`));
           process.exit(1);
@@ -1982,6 +2936,9 @@ async function main() {
     if (options.fix) {
       await handleFixCommand(options);
     }
+    if (options.update) {
+      await handleUpdateCommand(options);
+    }
     if (options.dir && !options.workspace) {
       console.error(color__default.red("Error:") + " --dir requires --workspace flag");
       console.log(
@@ -1997,11 +2954,11 @@ async function main() {
     console.clear();
     p__namespace.intro(color__default.bgCyan(color__default.black(` create-krispya v${pkg.version} `)));
     const monorepoRoot = await detectMonorepoRoot();
-    if (monorepoRoot && Object.keys(options).length === 0) {
+    if (monorepoRoot && !hasConfigOptions(options)) {
       await handleInteractiveMonorepoMode(monorepoRoot);
     }
     let generateOptions;
-    if (Object.keys(options).length > 0) {
+    if (options.yes) {
       const template = options.template ?? "vanilla";
       const baseTemplate = index.getBaseTemplate(template);
       const defaultName = getDefaultProjectName(template);
@@ -2012,7 +2969,7 @@ async function main() {
         libraryBundler: projectType === "library" ? options.bundler ?? "unbuild" : void 0,
         template,
         linter: options.linter ?? "oxlint",
-        formatter: options.formatter ?? "oxfmt",
+        formatter: options.formatter ?? "prettier",
         ...baseTemplate === "r3f" && {
           drei: options.drei ? {} : void 0,
           handle: options.handle ? {} : void 0,
@@ -2032,12 +2989,35 @@ async function main() {
         nodeVersion: options.nodeVersion ?? "latest"
       };
     } else {
-      generateOptions = await promptForOptions(name);
+      const presets = hasConfigOptions(options) ? {
+        type: options.type,
+        template: options.template,
+        bundler: options.bundler,
+        linter: options.linter,
+        formatter: options.formatter,
+        packageManager: options.packageManager,
+        nodeVersion: options.nodeVersion,
+        pnpmManageVersions: options.pnpmManageVersions,
+        drei: options.drei,
+        handle: options.handle,
+        leva: options.leva,
+        postprocessing: options.postprocessing,
+        rapier: options.rapier,
+        xr: options.xr,
+        uikit: options.uikit,
+        offscreen: options.offscreen,
+        zustand: options.zustand,
+        koota: options.koota,
+        triplex: options.triplex,
+        viverse: options.viverse
+      } : void 0;
+      generateOptions = await promptForOptions(name, presets);
     }
+    const isNonInteractive = options.yes ?? false;
     if (generateOptions.projectType === "monorepo") {
-      await handleMonorepoCreation(generateOptions);
+      await handleMonorepoCreation(generateOptions, isNonInteractive);
     } else {
-      await handleStandaloneProjectCreation(generateOptions);
+      await handleStandaloneProjectCreation(generateOptions, isNonInteractive);
     }
   });
   await program.parseAsync();