create-krispya 0.9.0 → 0.10.0

package/dist/cli.cjs

@@ -4,17 +4,17 @@
 const p = require('@clack/prompts');
 const color = require('chalk');
 const commander = require('commander');
-const node_fs = require('node:fs');
 const promises$1 = require('node:fs/promises');
 const node_module = require('node:module');
 const node_path = require('node:path');
 const node_process = require('node:process');
 const undici = require('undici');
-const index = require('./chunks/index.cjs');
+const workspace = require('./shared/create-krispya.DTHeUlq4.cjs');
 const Conf = require('conf');
 const promises = require('fs/promises');
 const fs = require('fs');
 const path = require('path');
+const node_fs = require('node:fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -49,13 +49,13 @@ function formatConfigSummary(options, inherited) {
     return lang === "typescript" ? "TypeScript" : lang === "javascript" ? "JavaScript" : lang;
   };
   const projectType = options.projectType ?? "app";
-  const baseTemplate = options.template ? index.getBaseTemplate(options.template) : "vanilla";
+  const baseTemplate = options.template ? workspace.getBaseTemplate(options.template) : "vanilla";
   if (baseTemplate === "react") {
     lines.push(formatRow("Framework", "React"));
   } else if (baseTemplate === "r3f") {
     lines.push(formatRow("Framework", "React Three Fiber"));
   }
-  const language = options.template ? index.getLanguageFromTemplate(options.template) : "typescript";
+  const language = options.template ? workspace.getLanguageFromTemplate(options.template) : "typescript";
   lines.push(formatRow("Language", formatLanguage(language)));
   if (projectType === "library") {
     lines.push(formatRow("Bundler", options.libraryBundler ?? "unbuild"));
@@ -66,15 +66,15 @@ function formatConfigSummary(options, inherited) {
   lines.push(
     formatRow(
       "Engine",
-      `${index.getEngineName(options.engine)}@${options.engine?.version ?? "latest"}`,
+      `${workspace.getEngineName(options.engine)}@${options.engine?.version ?? "latest"}`,
       engineInherited
     )
   );
   const pmInherited = inherited?.packageManager !== void 0;
   lines.push(
-    formatRow("Package manager", index.getPackageManagerName(options.packageManager), pmInherited)
+    formatRow("Package manager", workspace.getPackageManagerName(options.packageManager), pmInherited)
   );
-  if (index.getPackageManagerName(options.packageManager) === "pnpm") {
+  if (workspace.getPackageManagerName(options.packageManager) === "pnpm") {
     const versionManaged = options.pnpmManageVersions ? "yes" : "no";
     const pnpmVersionInherited = inherited?.pnpmManageVersions !== void 0;
     lines.push(formatRow("\u21B3 Version managed", versionManaged, pnpmVersionInherited, ""));
@@ -90,10 +90,13 @@ function formatConfigSummary(options, inherited) {
   const testing = options.testing ?? (projectType === "library" ? "vitest" : "none");
   lines.push(formatRow("Testing", testing));
   if (!inherited) {
+    lines.push(
+      formatRow("Editor config", options.ide === "none" ? "generic" : "generic + vscode")
+    );
     const configStrategy = options.configStrategy ?? "stealth";
     lines.push(formatRow("Config strategy", configStrategy));
   }
-  if (options.template && index.getBaseTemplate(options.template) === "r3f") {
+  if (options.template && workspace.getBaseTemplate(options.template) === "r3f") {
     const integrationNames = [
       options.drei && "drei",
       options.handle && "handle",
@@ -109,7 +112,7 @@ function formatConfigSummary(options, inherited) {
       options.viverse && "viverse"
     ].filter(Boolean);
     lines.push("");
-    lines.push(color__default.dim("Integrations"));
+    lines.push(color__default.dim("Features"));
     for (let i = 0; i < integrationNames.length; i += 2) {
       const left = `${color__default.green("\u25CF")} ${integrationNames[i]}`;
       const right = integrationNames[i + 1] ? `${color__default.green("\u25CF")} ${integrationNames[i + 1]}` : "";
@@ -129,7 +132,7 @@ function formatMonorepoConfigSummary(options) {
     return `${indent}${label} ${dots} ${value}`;
   };
   lines.push(
-    formatRow("Engine", `${index.getEngineName(options.engine)}@${options.engine.version ?? "latest"}`)
+    formatRow("Engine", `${workspace.getEngineName(options.engine)}@${options.engine.version ?? "latest"}`)
   );
   lines.push(formatRow("Package manager", options.packageManager));
   if (options.packageManager === "pnpm") {
@@ -138,6 +141,7 @@ function formatMonorepoConfigSummary(options) {
   }
   lines.push(formatRow("Linter", options.linter));
   lines.push(formatRow("Formatter", options.formatter));
+  lines.push(formatRow("Editor config", options.ide === "none" ? "generic" : "generic + vscode"));
   return lines.join("\n");
 }
 
@@ -156,12 +160,58 @@ function clearConfig() {
 function getConfigPath() {
   return config.path;
 }
-function getCustomTemplates() {
-  return config.get("customTemplates") ?? {};
-}
 
-function getDefaultOptions(template, name, projectType = "app", libraryBundler, integrations, inheritedSettings) {
-  const baseTemplate = index.getBaseTemplate(template);
+const R3F_INTEGRATION_OPTIONS = [
+  { value: "drei", label: "Drei" },
+  { value: "handle", label: "Handle" },
+  { value: "leva", label: "Leva" },
+  { value: "postprocessing", label: "Postprocessing" },
+  { value: "rapier", label: "Rapier" },
+  { value: "xr", label: "XR" },
+  { value: "uikit", label: "UIKit" },
+  { value: "offscreen", label: "Offscreen" },
+  { value: "zustand", label: "Zustand" },
+  { value: "koota", label: "Koota" },
+  { value: "triplex", label: "Triplex" },
+  { value: "viverse", label: "Viverse" }
+];
+function getR3fIntegrationFlags(features) {
+  if (!features) return {};
+  return {
+    drei: features.includes("drei") ? {} : void 0,
+    handle: features.includes("handle") ? {} : void 0,
+    leva: features.includes("leva") ? {} : void 0,
+    postprocessing: features.includes("postprocessing") ? {} : void 0,
+    rapier: features.includes("rapier") ? {} : void 0,
+    xr: features.includes("xr") ? {} : void 0,
+    uikit: features.includes("uikit") ? {} : void 0,
+    offscreen: features.includes("offscreen") ? {} : void 0,
+    zustand: features.includes("zustand") ? {} : void 0,
+    koota: features.includes("koota") ? {} : void 0,
+    triplex: features.includes("triplex") ? {} : void 0,
+    viverse: features.includes("viverse") ? {} : void 0
+  };
+}
+function getInitialR3fIntegrations(presets) {
+  if (!presets) return ["drei"];
+  const initialValues = R3F_INTEGRATION_OPTIONS.filter(({ value }) => presets[value]).map(
+    ({ value }) => value
+  );
+  return initialValues.length > 0 ? initialValues : ["drei"];
+}
+async function promptForProceed() {
+  const proceed = await p__namespace.confirm({
+    message: "Proceed with these settings?",
+    initialValue: true
+  });
+  if (p__namespace.isCancel(proceed)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return proceed;
+}
+function getDefaultOptions(template, name, projectType = "app", libraryBundler, features, inheritedSettings) {
+  const baseTemplate = workspace.getBaseTemplate(template);
   const base = {
     name,
     template,
@@ -174,71 +224,30 @@ function getDefaultOptions(template, name, projectType = "app", libraryBundler,
     formatter: inheritedSettings?.formatter ?? "prettier",
     // Libraries get vitest by default, apps don't
     testing: projectType === "library" ? "vitest" : "none",
-    configStrategy: getConfigStrategy()
+    configStrategy: getConfigStrategy(),
+    ide: "vscode"
+  };
+  return {
+    ...base,
+    ...baseTemplate === "r3f" ? getR3fIntegrationFlags(features) : {}
   };
-  if (baseTemplate === "r3f" && integrations) {
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
 }
 function getDefaultProjectName(template) {
-  const base = index.getBaseTemplate(template);
+  const base = workspace.getBaseTemplate(template);
   switch (base) {
     case "vanilla":
-      return `vanilla-${index.generateRandomName()}`;
+      return `vanilla-${workspace.generateRandomName()}`;
     case "react":
-      return `react-${index.generateRandomName()}`;
+      return `react-${workspace.generateRandomName()}`;
     case "r3f":
-      return `react-three-${index.generateRandomName()}`;
+      return `react-three-${workspace.generateRandomName()}`;
   }
 }
 async function promptForR3fIntegrations(presets) {
-  const initialValues = [];
-  if (presets) {
-    if (presets.drei) initialValues.push("drei");
-    if (presets.handle) initialValues.push("handle");
-    if (presets.leva) initialValues.push("leva");
-    if (presets.postprocessing) initialValues.push("postprocessing");
-    if (presets.rapier) initialValues.push("rapier");
-    if (presets.xr) initialValues.push("xr");
-    if (presets.uikit) initialValues.push("uikit");
-    if (presets.offscreen) initialValues.push("offscreen");
-    if (presets.zustand) initialValues.push("zustand");
-    if (presets.koota) initialValues.push("koota");
-    if (presets.triplex) initialValues.push("triplex");
-    if (presets.viverse) initialValues.push("viverse");
-  }
   const selected = await p__namespace.multiselect({
-    message: "R3F integrations",
-    options: [
-      { value: "drei", label: "Drei" },
-      { value: "handle", label: "Handle" },
-      { value: "leva", label: "Leva" },
-      { value: "postprocessing", label: "Postprocessing" },
-      { value: "rapier", label: "Rapier" },
-      { value: "xr", label: "XR" },
-      { value: "uikit", label: "UIKit" },
-      { value: "offscreen", label: "Offscreen" },
-      { value: "zustand", label: "Zustand" },
-      { value: "koota", label: "Koota" },
-      { value: "triplex", label: "Triplex" },
-      { value: "viverse", label: "Viverse" }
-    ],
-    initialValues: initialValues.length > 0 ? initialValues : ["drei"],
+    message: "R3F features",
+    options: [...R3F_INTEGRATION_OPTIONS],
+    initialValues: getInitialR3fIntegrations(presets),
     required: false
   });
   if (p__namespace.isCancel(selected)) {
@@ -247,7 +256,7 @@ async function promptForR3fIntegrations(presets) {
   }
   return selected;
 }
-async function promptForCustomization(template, name, projectType, integrations, inheritedSettings, presets) {
+async function promptForCustomization(template, name, projectType, features, inheritedSettings, presets) {
   let libraryBundler;
   if (projectType === "library") {
     const bundler = await p__namespace.select({
@@ -382,7 +391,19 @@ async function promptForCustomization(template, name, projectType, integrations,
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
-  const baseTemplate = index.getBaseTemplate(template);
+  const ideChoice = await p__namespace.select({
+    message: "IDE config",
+    options: [
+      { value: "vscode", label: "vscode" },
+      { value: "none", label: "None" }
+    ],
+    initialValue: presets?.ide ?? "vscode"
+  });
+  if (p__namespace.isCancel(ideChoice)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const baseTemplate = workspace.getBaseTemplate(template);
   const finalTemplate = language === "javascript" ? `${baseTemplate}-js` : baseTemplate;
   const base = {
     name,
@@ -395,26 +416,13 @@ async function promptForCustomization(template, name, projectType, integrations,
     linter,
     formatter,
     testing,
-    configStrategy: configStrategyChoice
+    configStrategy: configStrategyChoice,
+    ide: ideChoice
+  };
+  return {
+    ...base,
+    ...baseTemplate === "r3f" ? getR3fIntegrationFlags(features) : {}
   };
-  if (baseTemplate === "r3f" && integrations) {
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
 }
 async function promptForInitialPackage() {
   const choice = await p__namespace.select({
@@ -440,7 +448,8 @@ function getDefaultMonorepoOptions(name) {
     pnpmManageVersions: true,
     engine: { name: "node", version: "latest" },
     linter: "oxlint",
-    formatter: "prettier"
+    formatter: "prettier",
+    ide: "vscode"
   };
 }
 async function promptForMonorepoCustomization(name, presets) {
@@ -493,6 +502,18 @@ async function promptForMonorepoCustomization(name, presets) {
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
+  const ide = await p__namespace.select({
+    message: "IDE config",
+    options: [
+      { value: "vscode", label: "vscode" },
+      { value: "none", label: "None" }
+    ],
+    initialValue: presets?.ide ?? "vscode"
+  });
+  if (p__namespace.isCancel(ide)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
   return {
     name,
     projectType: "monorepo",
@@ -500,7 +521,8 @@ async function promptForMonorepoCustomization(name, presets) {
     packageManager: { name: "pnpm" },
     pnpmManageVersions: managePnpm,
     linter,
-    formatter
+    formatter,
+    ide
   };
 }
 async function promptForMonorepo(workspaceName, presets) {
@@ -508,6 +530,7 @@ async function promptForMonorepo(workspaceName, presets) {
   if (presets) {
     if (presets.linter) defaultOptions.linter = presets.linter;
     if (presets.formatter) defaultOptions.formatter = presets.formatter;
+    if (presets.ide) defaultOptions.ide = presets.ide;
     if (presets.engine) defaultOptions.engine = presets.engine;
     if (presets.pnpmManageVersions !== void 0)
       defaultOptions.pnpmManageVersions = presets.pnpmManageVersions;
@@ -516,26 +539,15 @@ async function promptForMonorepo(workspaceName, presets) {
     formatMonorepoConfigSummary({
       name: defaultOptions.name,
       engine: defaultOptions.engine ?? { name: "node", version: "latest" },
-      packageManager: index.getPackageManagerName(defaultOptions.packageManager),
+      packageManager: workspace.getPackageManagerName(defaultOptions.packageManager),
       pnpmManageVersions: defaultOptions.pnpmManageVersions,
       linter: defaultOptions.linter ?? "oxlint",
-      formatter: defaultOptions.formatter ?? "prettier"
+      formatter: defaultOptions.formatter ?? "prettier",
+      ide: defaultOptions.ide ?? "vscode"
     }),
     "Workspace Configuration"
   );
-  const proceed = await p__namespace.select({
-    message: "Proceed with these settings?",
-    options: [
-      { value: "continue", label: "Yes, continue" },
-      { value: "customize", label: "No, customize settings" }
-    ],
-    initialValue: "continue"
-  });
-  if (p__namespace.isCancel(proceed)) {
-    p__namespace.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (proceed === "continue") {
+  if (await promptForProceed()) {
     return defaultOptions;
   }
   return promptForMonorepoCustomization(workspaceName, presets);
@@ -545,8 +557,8 @@ async function promptForOptions(name, presets) {
   if (!projectName) {
     const nameResult = await p__namespace.text({
       message: "What is your project named?",
-      placeholder: index.generateRandomName(),
-      defaultValue: index.generateRandomName(),
+      placeholder: workspace.generateRandomName(),
+      defaultValue: workspace.generateRandomName(),
       validate: (value) => {
         if (!value.length) return "Project name is required";
       }
@@ -575,41 +587,6 @@ async function promptForOptions(name, presets) {
   }
   return promptForPackageOptions(projectName, projectType, void 0, presets);
 }
-function customTemplateToOptions(customTemplate, name, projectType, inheritedSettings) {
-  const baseTemplate = customTemplate.baseTemplate;
-  const template = baseTemplate;
-  const base = {
-    name,
-    template,
-    projectType,
-    packageManager: inheritedSettings?.packageManager ?? { name: "pnpm" },
-    pnpmManageVersions: inheritedSettings?.pnpmManageVersions ?? true,
-    engine: inheritedSettings?.engine ?? { name: "node", version: "latest" },
-    linter: inheritedSettings?.linter ?? customTemplate.linter,
-    formatter: inheritedSettings?.formatter ?? customTemplate.formatter,
-    testing: customTemplate.testing,
-    configStrategy: customTemplate.configStrategy ?? getConfigStrategy()
-  };
-  if (baseTemplate === "r3f" && customTemplate.integrations) {
-    const integrations = customTemplate.integrations;
-    return {
-      ...base,
-      drei: integrations.includes("drei") ? {} : void 0,
-      handle: integrations.includes("handle") ? {} : void 0,
-      leva: integrations.includes("leva") ? {} : void 0,
-      postprocessing: integrations.includes("postprocessing") ? {} : void 0,
-      rapier: integrations.includes("rapier") ? {} : void 0,
-      xr: integrations.includes("xr") ? {} : void 0,
-      uikit: integrations.includes("uikit") ? {} : void 0,
-      offscreen: integrations.includes("offscreen") ? {} : void 0,
-      zustand: integrations.includes("zustand") ? {} : void 0,
-      koota: integrations.includes("koota") ? {} : void 0,
-      triplex: integrations.includes("triplex") ? {} : void 0,
-      viverse: integrations.includes("viverse") ? {} : void 0
-    };
-  }
-  return base;
-}
 function presetsToInheritedSettings(presets) {
   if (!presets) return void 0;
   return {
@@ -621,948 +598,308 @@ function presetsToInheritedSettings(presets) {
   };
 }
 async function promptForPackageOptions(projectName, projectType, inheritedSettings, presets) {
-  const builtInOptions = [
-    { value: "vanilla", label: "Vanilla" },
-    { value: "react", label: "React", hint: "experimental" },
-    { value: "r3f", label: "React Three Fiber", hint: "experimental" }
-  ];
-  const customTemplates = getCustomTemplates();
-  const customOptions = Object.keys(customTemplates).map((name) => ({
-    value: `custom:${name}`,
-    label: name,
-    hint: "saved template"
-  }));
-  const allOptions = [...builtInOptions, ...customOptions];
   const templateSelection = await p__namespace.select({
     message: "Select a template",
-    options: allOptions,
-    initialValue: presets?.template ?? "vanilla"
+    options: [
+      { value: "vanilla", label: "Vanilla" },
+      { value: "react", label: "React", hint: "experimental" },
+      { value: "r3f", label: "React Three Fiber", hint: "experimental" }
+    ],
+    initialValue: presets?.template ? workspace.getBaseTemplate(presets.template) : "vanilla"
   });
   if (p__namespace.isCancel(templateSelection)) {
     p__namespace.cancel("Operation cancelled.");
     process.exit(0);
   }
-  const selection = templateSelection;
-  if (selection.startsWith("custom:")) {
-    const customName = selection.slice(7);
-    const customTemplate = customTemplates[customName];
-    const defaultOptions2 = customTemplateToOptions(
-      customTemplate,
-      projectName,
-      projectType,
-      inheritedSettings
-    );
-    const configTitle2 = inheritedSettings ? `Template: ${customName} (using workspace settings)` : `Template: ${customName}`;
-    p__namespace.note(formatConfigSummary(defaultOptions2, inheritedSettings), configTitle2);
-    const proceed2 = await p__namespace.select({
-      message: "Proceed with these settings?",
-      options: [
-        { value: "continue", label: "Yes, continue" },
-        { value: "customize", label: "No, customize settings" }
-      ],
-      initialValue: "continue"
-    });
-    if (p__namespace.isCancel(proceed2)) {
-      p__namespace.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    if (proceed2 === "continue") {
-      return defaultOptions2;
-    }
-    return promptForCustomization(
-      customTemplate.baseTemplate,
-      projectName,
-      projectType,
-      customTemplate.integrations,
-      inheritedSettings
-    );
-  }
-  const template = selection;
-  const baseTemplate = index.getBaseTemplate(template);
-  let integrations;
+  const template = templateSelection;
+  const baseTemplate = workspace.getBaseTemplate(template);
+  let features;
   if (baseTemplate === "r3f") {
-    integrations = await promptForR3fIntegrations(presets);
+    features = await promptForR3fIntegrations(presets);
   }
   const defaultOptions = getDefaultOptions(
     template,
     projectName,
     projectType,
     presets?.bundler,
-    integrations,
+    features,
     inheritedSettings ?? presetsToInheritedSettings(presets)
   );
+  if (presets?.ide && !inheritedSettings) {
+    defaultOptions.ide = presets.ide;
+  }
   const configTitle = inheritedSettings ? "Template Configuration (using workspace settings)" : "Template Configuration";
   p__namespace.note(formatConfigSummary(defaultOptions, inheritedSettings), configTitle);
-  const proceed = await p__namespace.select({
-    message: "Proceed with these settings?",
-    options: [
-      { value: "continue", label: "Yes, continue" },
-      { value: "customize", label: "No, customize settings" }
-    ],
-    initialValue: "continue"
-  });
-  if (p__namespace.isCancel(proceed)) {
-    p__namespace.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (proceed === "continue") {
+  if (await promptForProceed()) {
     return defaultOptions;
   }
   return promptForCustomization(
     template,
     projectName,
     projectType,
-    integrations,
+    features,
     inheritedSettings,
     presets
   );
 }
 
-async function detectCurrentConfig(root, isMonorepo = true) {
-  let name = root.split(/[/\\]/).pop() ?? "workspace";
-  let packageManager = "pnpm";
-  try {
-    const pkgPath = path.join(root, "package.json");
-    const content = await promises.readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    if (pkgJson.name) {
-      name = pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
+async function promptForAiAgentPlatforms(isNonInteractive) {
+  const savedPlatforms = getAiPlatforms();
+  if (isNonInteractive) {
+    return savedPlatforms ?? workspace.ALL_AI_PLATFORMS;
+  }
+  if (savedPlatforms && savedPlatforms.length > 0) {
+    const savedLabels = savedPlatforms.map((platform) => workspace.AI_PLATFORM_LABELS[platform]).join(", ");
+    const useDefault = await p__namespace.confirm({
+      message: `Add AI rules? ${color__default.dim(`(${savedLabels})`)}`,
+      initialValue: true
+    });
+    if (p__namespace.isCancel(useDefault)) {
+      return [];
     }
-    if (pkgJson.packageManager) {
-      packageManager = pkgJson.packageManager.split("@")[0] ?? packageManager;
+    if (useDefault) {
+      return savedPlatforms;
     }
-  } catch {
   }
-  const tooling = await index.detectTooling(root);
-  const configStrategy = isMonorepo ? void 0 : await detectStandaloneConfigStrategy(root);
-  return {
-    name,
-    linter: tooling.linter ?? "oxlint",
-    formatter: tooling.formatter ?? "prettier",
-    packageManager,
-    isMonorepo,
-    configStrategy
-  };
-}
-async function detectStandaloneConfigStrategy(root) {
-  const hasStealthConfig = await Promise.all([
-    fileExists$1(path.join(root, ".config/tsconfig.app.json")),
-    fileExists$1(path.join(root, ".config/tsconfig.node.json")),
-    fileExists$1(path.join(root, ".config/prettier.json")),
-    fileExists$1(path.join(root, ".config/oxlint.json"))
-  ]).then((matches) => matches.some(Boolean));
-  return hasStealthConfig ? "stealth" : "root";
-}
-async function generateExpectedFiles(config) {
-  const { name, linter, formatter, packageManager, isMonorepo, configStrategy } = config;
-  const versions = linter === "biome" || formatter === "biome" ? await index.resolveMonorepoRootPackageVersions({ linter, formatter }) : {};
-  const aiFilesMap = {};
-  index.generateAiFiles(aiFilesMap, {
-    name,
-    packageManager,
-    linter,
-    formatter,
-    isMonorepo,
-    configStrategy,
-    platforms: index.ALL_AI_PLATFORMS
+  const selected = await p__namespace.multiselect({
+    message: "Add AI rules?",
+    options: workspace.ALL_AI_PLATFORMS.map((platform) => ({
+      value: platform,
+      label: workspace.AI_PLATFORM_LABELS[platform],
+      hint: workspace.AI_PLATFORM_HINTS[platform]
+    })),
+    initialValues: ["agents"],
+    required: false
   });
-  const vscodeFiles = {};
-  index.generateVscodeFiles(vscodeFiles, linter, formatter);
-  const configPackages = {};
-  if (isMonorepo) {
-    index.generateTypescriptConfigPackage(configPackages);
-    if (linter === "oxlint") {
-      index.generateOxlintConfigPackage(configPackages);
-    } else if (linter === "eslint") {
-      index.generateEslintConfigPackage(configPackages);
-    }
-    if (formatter === "oxfmt") {
-      index.generateOxfmtConfigPackage(configPackages);
-    } else if (formatter === "prettier") {
-      index.generatePrettierConfigPackage(configPackages);
+  if (p__namespace.isCancel(selected)) {
+    return [];
+  }
+  return selected;
+}
+
+async function checkAnyExists(paths) {
+  for (const path of paths) {
+    try {
+      await promises.access(path, promises.constants.F_OK);
+      return true;
+    } catch {
     }
   }
-  const workspaceConfig = {};
-  const rootConfig = {};
-  rootConfig[".gitignore"] = index.generateGitignore(isMonorepo ? "workspace-root" : "standalone");
-  rootConfig[".gitattributes"] = {
-    type: "text",
-    content: `* text=auto eol=lf
-*.{cmd,[cC][mM][dD]} text eol=crlf
-*.{bat,[bB][aA][tT]} text eol=crlf
-`
-  };
-  if (linter === "biome" || formatter === "biome") {
-    const biomeVersion = index.getResolvedPackageVersion(versions, "@biomejs/biome");
-    const biomeConfig = {
-      $schema: `https://biomejs.dev/schemas/${biomeVersion}/schema.json`,
-      vcs: {
-        enabled: true,
-        clientKind: "git",
-        useIgnoreFile: true
-      },
-      linter: {
-        enabled: linter === "biome",
-        rules: {
-          recommended: true
-        }
-      },
-      formatter: {
-        enabled: formatter === "biome"
-      }
-    };
-    rootConfig["biome.json"] = {
-      type: "text",
-      content: JSON.stringify(biomeConfig, null, 2)
-    };
+  return false;
+}
+async function validateWorkspace(monorepoRoot) {
+  const errors = [];
+  const tsConfigPath = path.join(monorepoRoot, ".config/typescript/package.json");
+  try {
+    await promises.access(tsConfigPath, promises.constants.F_OK);
+  } catch {
+    errors.push("Missing .config/typescript package");
   }
-  return {
-    "ai-files": aiFilesMap,
-    vscode: vscodeFiles,
-    "config-packages": configPackages,
-    "workspace-config": workspaceConfig,
-    "root-config": rootConfig
-  };
+  const linterPaths = [
+    path.join(monorepoRoot, ".config/oxlint/package.json"),
+    path.join(monorepoRoot, ".config/eslint/package.json"),
+    path.join(monorepoRoot, "eslint.config.js"),
+    path.join(monorepoRoot, "biome.json")
+  ];
+  const hasLinter = await checkAnyExists(linterPaths);
+  if (!hasLinter) {
+    errors.push(
+      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
+    );
+  }
+  const formatterPaths = [
+    path.join(monorepoRoot, ".config/oxfmt/package.json"),
+    path.join(monorepoRoot, ".config/prettier/package.json"),
+    path.join(monorepoRoot, ".prettierrc.json"),
+    path.join(monorepoRoot, "biome.json")
+  ];
+  const hasFormatter = await checkAnyExists(formatterPaths);
+  if (!hasFormatter) {
+    errors.push(
+      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
+    );
+  }
+  return { valid: errors.length === 0, errors };
 }
+
 async function fileExists$1(path) {
   try {
-    await promises.access(path, fs.constants.F_OK);
+    await promises$1.access(path, node_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
-        });
+function calculateWorkspaceRoot(packagePath) {
+  const segments = packagePath.split(/[/\\]/).filter(Boolean);
+  return segments.map(() => "..").join("/");
+}
+async function detectMonorepoRoot() {
+  let currentDir = node_process.cwd();
+  const root = node_path.resolve("/");
+  while (currentDir !== root) {
+    const workspaceFile = node_path.join(currentDir, "pnpm-workspace.yaml");
+    try {
+      await promises$1.access(workspaceFile, node_fs.constants.F_OK);
+      const content = await promises$1.readFile(workspaceFile, "utf-8");
+      if (content.includes("packages:")) {
+        return currentDir;
       }
+    } catch {
     }
-    if (changes.length === 0) continue;
-    const hasUserModifications = changes.some((c) => c.status === "modified");
-    categories.push({
-      category,
-      label: categoryLabels[category],
-      changes,
-      hasUserModifications
-    });
+    currentDir = node_path.dirname(currentDir);
   }
-  return categories;
+  return null;
 }
-async function getWorkspaceConfigUpdates(root) {
-  const workspacePath = path.join(root, "pnpm-workspace.yaml");
-  const changes = [];
-  let currentContent = "";
-  let exists = false;
+async function detectPackageRoot() {
+  let currentDir = node_process.cwd();
+  const root = node_path.resolve("/");
+  while (currentDir !== root) {
+    if (await fileExists$1(node_path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    currentDir = node_path.dirname(currentDir);
+  }
+  return await fileExists$1(node_path.join(root, "package.json")) ? root : null;
+}
+async function parseWorkspaceDirectories(monorepoRoot) {
   try {
-    currentContent = await promises.readFile(workspacePath, "utf-8");
-    exists = true;
+    const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+    const content = await promises$1.readFile(workspaceFile, "utf-8");
+    return workspace.parseWorkspaceYamlContent(content);
   } catch {
+    return [];
   }
-  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;
+}
+async function detectWorkspaceSettings(monorepoRoot) {
+  try {
+    const tooling = await workspace.detectTooling(monorepoRoot);
+    const pkgPath = node_path.join(monorepoRoot, "package.json");
+    const content = await promises$1.readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    const packageManager = workspace.parsePackageManager(pkgJson.packageManager);
+    const engine = workspace.parseEngine(pkgJson.engines);
+    let pnpmManageVersions;
+    try {
+      const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+      const workspaceContent = await promises$1.readFile(workspaceFile, "utf-8");
+      pnpmManageVersions = workspaceContent.includes("manage-package-manager-versions: true");
+    } catch {
     }
+    return {
+      linter: tooling.linter,
+      formatter: tooling.formatter,
+      packageManager,
+      engine,
+      pnpmManageVersions
+    };
+  } catch {
+    return {};
   }
-  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);
+async function detectExistingConfigs(monorepoRoot) {
+  const configs = {};
+  const eslintPath = node_path.join(monorepoRoot, "eslint.config.js");
+  if (await fileExists$1(eslintPath)) {
+    configs.linter = "eslint";
+    configs.eslintConfigPath = eslintPath;
   }
-}
-function formatFileChange(change) {
-  const icon = change.status === "added" ? "+" : change.status === "modified" ? "~" : "=";
-  return `  ${icon} ${change.path}`;
-}
-const LINTER_DEPS = {
-  oxlint: "oxlint",
-  eslint: "eslint",
-  biome: "@biomejs/biome"
-};
-const FORMATTER_DEPS = {
-  oxfmt: "oxfmt",
-  prettier: "prettier",
-  biome: "@biomejs/biome"
-};
-const LINTER_CONFIG_PACKAGES = {
-  oxlint: "@config/oxlint",
-  eslint: "@config/eslint",
-  biome: null
-  // biome uses root biome.json
-};
-const FORMATTER_CONFIG_PACKAGES = {
-  oxfmt: "@config/oxfmt",
-  prettier: "@config/prettier",
-  biome: null
-  // biome uses root biome.json
-};
-function needsMigration(current, target) {
-  const linterChange = target.linter && target.linter !== current.linter;
-  const formatterChange = target.formatter && target.formatter !== current.formatter;
-  return linterChange || formatterChange || false;
-}
-async function getMigrationPlan(current, target, root) {
-  const toLinter = target.linter ?? current.linter;
-  const toFormatter = target.formatter ?? current.formatter;
-  const targetVersions = toLinter === "biome" || toFormatter === "biome" ? await index.resolveMonorepoRootPackageVersions({
-    linter: toLinter,
-    formatter: toFormatter
-  }) : {};
-  const biomeSchemaUrl = toLinter === "biome" || toFormatter === "biome" ? `https://biomejs.dev/schemas/${index.getResolvedPackageVersion(
-    targetVersions,
-    "@biomejs/biome"
-  )}/schema.json` : "";
-  const changes = [];
-  if (toLinter !== current.linter) {
-    if (current.linter !== "biome") {
-      changes.push({
-        type: "remove-dir",
-        path: `.config/${current.linter}`,
-        description: `Remove @config/${current.linter} package`
-      });
-    }
-    if (toLinter !== "biome") {
-      const files = {};
-      if (toLinter === "oxlint") {
-        index.generateOxlintConfigPackage(files);
-      } else if (toLinter === "eslint") {
-        index.generateEslintConfigPackage(files);
-      }
-      for (const [path, file] of Object.entries(files)) {
-        if (file.type === "text") {
-          changes.push({
-            type: "add-file",
-            path,
-            description: `Add ${path}`,
-            content: file.content
-          });
-        }
-      }
-    }
-    if (toLinter === "biome" && toFormatter === "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config",
-        content: JSON.stringify(
-          {
-            $schema: biomeSchemaUrl,
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: true, rules: { recommended: true } },
-            formatter: { enabled: true }
-          },
-          null,
-          2
-        )
-      });
-    } else if (toLinter === "biome" && toFormatter !== "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config (linter only)",
-        content: JSON.stringify(
-          {
-            $schema: biomeSchemaUrl,
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: true, rules: { recommended: true } },
-            formatter: { enabled: false }
-          },
-          null,
-          2
-        )
-      });
-    }
-    if (current.linter === "biome" && toLinter !== "biome" && current.formatter !== "biome" && toFormatter !== "biome") {
-      changes.push({
-        type: "remove-file",
-        path: "biome.json",
-        description: "Remove biome.json"
-      });
-    }
+  const prettierPath = node_path.join(monorepoRoot, ".prettierrc.json");
+  if (await fileExists$1(prettierPath)) {
+    configs.formatter = "prettier";
+    configs.prettierConfigPath = prettierPath;
   }
-  if (toFormatter !== current.formatter) {
-    const formatterSameAsLinter = current.formatter === current.linter;
-    if (current.formatter !== "biome" && !formatterSameAsLinter) {
-      changes.push({
-        type: "remove-dir",
-        path: `.config/${current.formatter}`,
-        description: `Remove @config/${current.formatter} package`
-      });
-    }
-    const newFormatterSameAsLinter = toFormatter === toLinter;
-    if (toFormatter !== "biome" && !newFormatterSameAsLinter) {
-      const files = {};
-      if (toFormatter === "oxfmt") {
-        index.generateOxfmtConfigPackage(files);
-      } else if (toFormatter === "prettier") {
-        index.generatePrettierConfigPackage(files);
-      }
-      for (const [path, file] of Object.entries(files)) {
-        if (file.type === "text") {
-          changes.push({
-            type: "add-file",
-            path,
-            description: `Add ${path}`,
-            content: file.content
-          });
-        }
-      }
-    }
-    if (toFormatter === "biome" && toLinter !== "biome") {
-      changes.push({
-        type: "add-file",
-        path: "biome.json",
-        description: "Add biome.json config (formatter only)",
-        content: JSON.stringify(
-          {
-            $schema: biomeSchemaUrl,
-            vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
-            linter: { enabled: false },
-            formatter: { enabled: true }
-          },
-          null,
-          2
-        )
-      });
-    }
-    if (current.formatter === "biome" && toFormatter !== "biome" && current.linter !== "biome" && toLinter !== "biome") {
-      changes.push({
-        type: "remove-file",
-        path: "biome.json",
-        description: "Remove biome.json"
-      });
-    }
+  const biomePath = node_path.join(monorepoRoot, "biome.json");
+  if (await fileExists$1(biomePath)) {
+    configs.biomeConfigPath = biomePath;
+    if (!configs.linter) configs.linter = "biome";
+    if (!configs.formatter) configs.formatter = "biome";
   }
-  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
-  };
+  return configs;
 }
-async function getSubPackageUpdates(root, current, toLinter, toFormatter) {
-  const updates = [];
-  const workspacePath = path.join(root, "pnpm-workspace.yaml");
-  let workspaceContent;
+async function getMonorepoScope(monorepoRoot) {
   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 {
+    const pkgPath = node_path.join(monorepoRoot, "package.json");
+    const content = await promises$1.readFile(pkgPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    if (pkgJson.name) {
+      return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
     }
+  } catch {
   }
-  return updates;
+  return monorepoRoot.split(/[/\\]/).pop() ?? "workspace";
 }
-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);
+async function getWorkspacePackages(monorepoRoot) {
+  const packagesDir = node_path.join(monorepoRoot, "packages");
+  try {
+    const entries = await promises$1.readdir(packagesDir, { withFileTypes: true });
+    const names = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
       try {
-        await promises.rm(fullPath);
+        const content = await promises$1.readFile(
+          node_path.join(packagesDir, entry.name, "package.json"),
+          "utf-8"
+        );
+        const pkg = JSON.parse(content);
+        if (pkg.name) names.push(pkg.name);
       } catch {
       }
     }
+    return names;
+  } catch {
+    return [];
   }
-  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);
-    }
+}
+async function ensureConfigInWorkspace(monorepoRoot) {
+  const workspacePath = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await promises$1.readFile(workspacePath, "utf-8");
+  } catch {
+    content = `packages:
+  - '.config/*'
+  - 'packages/*'
+`;
+    await promises$1.writeFile(workspacePath, content);
+    return;
   }
-  await updateRootPackageJson(root, plan);
-  for (const update of plan.subPackageUpdates) {
-    await updateSubPackageJson(root, update);
+  if (content.includes(".config/*")) {
+    return;
   }
-}
-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 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");
   }
-  const resolvedVersions = await index.resolveMonorepoRootPackageVersions({
-    linter: plan.toLinter,
-    formatter: plan.toFormatter
-  });
-  const newLinterDep = LINTER_DEPS[plan.toLinter];
-  devDeps[newLinterDep] = index.formatResolvedPackageVersion(resolvedVersions, newLinterDep);
-  if (plan.toFormatter !== plan.toLinter) {
-    const newFormatterDep = FORMATTER_DEPS[plan.toFormatter];
-    devDeps[newFormatterDep] = index.formatResolvedPackageVersion(resolvedVersions, newFormatterDep);
-  }
-  pkg.devDependencies = Object.fromEntries(
-    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
-  );
-  const scripts = pkg.scripts ?? {};
-  if (plan.toLinter === "oxlint") {
-    scripts.lint = "oxlint .";
-  } else if (plan.toLinter === "eslint") {
-    scripts.lint = "eslint .";
-  } else if (plan.toLinter === "biome") {
-    scripts.lint = "biome check .";
-  }
-  if (plan.toFormatter === "oxfmt") {
-    scripts.format = "oxfmt .";
-  } else if (plan.toFormatter === "prettier") {
-    scripts.format = "prettier --write .";
-  } else if (plan.toFormatter === "biome") {
-    scripts.format = "biome format . --write";
-  }
-  pkg.scripts = scripts;
-  await promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-}
-async function updateSubPackageJson(root, update) {
-  const pkgPath = path.join(root, update.path);
-  const content = await promises.readFile(pkgPath, "utf-8");
-  const pkg = JSON.parse(content);
-  const devDeps = pkg.devDependencies ?? {};
-  for (const dep of update.remove) {
-    delete devDeps[dep];
-  }
-  for (const dep of update.add) {
-    devDeps[dep] = "workspace:*";
-  }
-  pkg.devDependencies = Object.fromEntries(
-    Object.entries(devDeps).sort(([a], [b]) => a.localeCompare(b))
-  );
-  await promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-}
-function formatMigrationChange(change) {
-  const icon = change.type === "remove-dir" || change.type === "remove-file" ? "-" : change.type === "add-file" ? "+" : "~";
-  return `  ${icon} ${change.description}`;
+  await promises$1.writeFile(workspacePath, content);
 }
 
-async function checkAnyExists(paths) {
-  for (const path of paths) {
-    try {
-      await promises.access(path, promises.constants.F_OK);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function validateWorkspace(monorepoRoot) {
-  const errors = [];
-  const tsConfigPath = path.join(monorepoRoot, ".config/typescript/package.json");
-  try {
-    await promises.access(tsConfigPath, promises.constants.F_OK);
-  } catch {
-    errors.push("Missing .config/typescript package");
-  }
-  const linterPaths = [
-    path.join(monorepoRoot, ".config/oxlint/package.json"),
-    path.join(monorepoRoot, ".config/eslint/package.json"),
-    path.join(monorepoRoot, "eslint.config.js"),
-    path.join(monorepoRoot, "biome.json")
-  ];
-  const hasLinter = await checkAnyExists(linterPaths);
-  if (!hasLinter) {
-    errors.push(
-      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
-    );
-  }
-  const formatterPaths = [
-    path.join(monorepoRoot, ".config/oxfmt/package.json"),
-    path.join(monorepoRoot, ".config/prettier/package.json"),
-    path.join(monorepoRoot, ".prettierrc.json"),
-    path.join(monorepoRoot, "biome.json")
-  ];
-  const hasFormatter = await checkAnyExists(formatterPaths);
-  if (!hasFormatter) {
-    errors.push(
-      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
-    );
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
-const pkg = require$1("../package.json");
-const META_OPTIONS = [
-  "clearConfig",
-  "configPath",
-  "check",
-  "fix",
-  "update",
-  "yes",
-  "workspace",
-  "path",
-  "dir"
-];
-function hasConfigOptions(options) {
-  return Object.keys(options).some(
-    (key) => !META_OPTIONS.includes(key)
-  );
-}
-async function fileExists(path) {
-  try {
-    await promises$1.access(path, node_fs.constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function promptForAiPlatforms(isNonInteractive) {
-  const savedPlatforms = getAiPlatforms();
-  if (isNonInteractive) {
-    return savedPlatforms ?? index.ALL_AI_PLATFORMS;
-  }
-  if (savedPlatforms && savedPlatforms.length > 0) {
-    const savedLabels = savedPlatforms.map((plat) => index.AI_PLATFORM_LABELS[plat]).join(", ");
-    const useDefault = await p__namespace.confirm({
-      message: `Add AI rules? ${color__default.dim(`(${savedLabels})`)}`,
-      initialValue: true
-    });
-    if (p__namespace.isCancel(useDefault)) {
-      return [];
-    }
-    if (useDefault) {
-      return savedPlatforms;
-    }
-  }
-  const selected = await p__namespace.multiselect({
-    message: "Add AI rules?",
-    options: index.ALL_AI_PLATFORMS.map((platform) => ({
-      value: platform,
-      label: index.AI_PLATFORM_LABELS[platform],
-      hint: index.AI_PLATFORM_HINTS[platform]
-    })),
-    initialValues: ["agents"],
-    required: false
-  });
-  if (p__namespace.isCancel(selected)) {
-    return [];
-  }
-  const platforms = selected;
-  if (platforms.length === 0) {
-    return [];
-  }
-  return platforms;
-}
-async function writeGeneratedFiles(basePath, files) {
-  const filePaths = Object.keys(files).sort();
-  for (const filePath of filePaths) {
-    const fullFilePath = node_path.join(basePath, filePath);
-    await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
-    const file = files[filePath];
-    if (file.type === "text") {
-      await promises$1.writeFile(fullFilePath, file.content);
-    } else {
-      const response = await undici.fetch(file.url);
-      await promises$1.writeFile(fullFilePath, response.body);
-    }
-  }
-}
-function calculateWorkspaceRoot(packagePath) {
-  const segments = packagePath.split(/[/\\]/).filter(Boolean);
-  return segments.map(() => "..").join("/");
-}
-async function detectMonorepoRoot() {
-  let currentDir = node_process.cwd();
-  const root = node_path.resolve("/");
-  while (currentDir !== root) {
-    const workspaceFile = node_path.join(currentDir, "pnpm-workspace.yaml");
-    try {
-      await promises$1.access(workspaceFile, node_fs.constants.F_OK);
-      const content = await promises$1.readFile(workspaceFile, "utf-8");
-      if (content.includes("packages:")) {
-        return currentDir;
-      }
-    } catch {
-    }
-    currentDir = node_path.dirname(currentDir);
-  }
-  return null;
-}
-async function detectPackageRoot() {
-  let currentDir = node_process.cwd();
-  const root = node_path.resolve("/");
-  while (currentDir !== root) {
-    if (await fileExists(node_path.join(currentDir, "package.json"))) {
-      return currentDir;
-    }
-    currentDir = node_path.dirname(currentDir);
-  }
-  return await fileExists(node_path.join(root, "package.json")) ? root : null;
-}
-async function parseWorkspaceDirectories(monorepoRoot) {
-  try {
-    const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
-    const content = await promises$1.readFile(workspaceFile, "utf-8");
-    return index.parseWorkspaceYamlContent(content);
-  } catch {
-    return [];
-  }
-}
-async function detectWorkspaceSettings(monorepoRoot) {
-  try {
-    const tooling = await index.detectTooling(monorepoRoot);
-    const pkgPath = node_path.join(monorepoRoot, "package.json");
-    const content = await promises$1.readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    const packageManager = index.parsePackageManager(pkgJson.packageManager);
-    const engine = index.parseEngine(pkgJson.engines);
-    let pnpmManageVersions;
-    try {
-      const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
-      const workspaceContent = await promises$1.readFile(workspaceFile, "utf-8");
-      pnpmManageVersions = workspaceContent.includes("manage-package-manager-versions: true");
-    } catch {
-    }
-    return {
-      linter: tooling.linter,
-      formatter: tooling.formatter,
-      packageManager,
-      engine,
-      pnpmManageVersions
-    };
-  } catch {
-    return {};
-  }
-}
-async function detectExistingConfigs(monorepoRoot) {
-  const configs = {};
-  const eslintPath = node_path.join(monorepoRoot, "eslint.config.js");
-  if (await fileExists(eslintPath)) {
-    configs.linter = "eslint";
-    configs.eslintConfigPath = eslintPath;
-  }
-  const prettierPath = node_path.join(monorepoRoot, ".prettierrc.json");
-  if (await fileExists(prettierPath)) {
-    configs.formatter = "prettier";
-    configs.prettierConfigPath = prettierPath;
-  }
-  const biomePath = node_path.join(monorepoRoot, "biome.json");
-  if (await fileExists(biomePath)) {
-    configs.biomeConfigPath = biomePath;
-    if (!configs.linter) configs.linter = "biome";
-    if (!configs.formatter) configs.formatter = "biome";
-  }
-  return configs;
-}
-async function getMonorepoScope(monorepoRoot) {
-  try {
-    const pkgPath = node_path.join(monorepoRoot, "package.json");
-    const content = await promises$1.readFile(pkgPath, "utf-8");
-    const pkgJson = JSON.parse(content);
-    if (pkgJson.name) {
-      return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
-    }
-  } catch {
-  }
-  return monorepoRoot.split(/[/\\]/).pop() ?? "workspace";
-}
-async function getWorkspacePackages(monorepoRoot) {
-  const packagesDir = node_path.join(monorepoRoot, "packages");
-  try {
-    const { readdir } = await import('fs/promises');
-    const entries = await readdir(packagesDir, { withFileTypes: true });
-    const names = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      try {
-        const content = await promises$1.readFile(
-          node_path.join(packagesDir, entry.name, "package.json"),
-          "utf-8"
-        );
-        const pkg2 = JSON.parse(content);
-        if (pkg2.name) names.push(pkg2.name);
-      } catch {
-      }
-    }
-    return names;
-  } catch {
-    return [];
-  }
-}
-async function ensureConfigInWorkspace(monorepoRoot) {
-  const workspacePath = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
-  let content;
-  try {
-    content = await promises$1.readFile(workspacePath, "utf-8");
-  } catch {
-    content = `packages:
-  - ".config/*"
-  - "packages/*"
-`;
-    await promises$1.writeFile(workspacePath, content);
-    return;
-  }
-  if (content.includes(".config/*") || content.includes('".config/*"')) {
-    return;
+async function handleCheckCommand() {
+  const monorepoRoot = await detectMonorepoRoot();
+  if (!monorepoRoot) {
+    console.log(color__default.red("\u2717") + " Not a monorepo workspace");
+    process.exit(1);
   }
-  const lines = content.split("\n");
-  const packagesIndex = lines.findIndex((line) => line.trim().startsWith("packages:"));
-  if (packagesIndex === -1) {
-    content = `packages:
-  - ".config/*"
-${content}`;
+  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  if (valid) {
+    console.log(color__default.green("\u2713") + " Valid monorepo workspace");
+    console.log(color__default.dim(`  ${monorepoRoot}`));
   } else {
-    lines.splice(packagesIndex + 1, 0, '  - ".config/*"');
-    content = lines.join("\n");
+    console.log(color__default.red("\u2717") + " Invalid monorepo workspace");
+    console.log(color__default.dim(`  ${monorepoRoot}`));
+    for (const error of errors) {
+      console.log(color__default.red(`  \u2022 ${error}`));
+    }
   }
-  await promises$1.writeFile(workspacePath, content);
+  process.exit(valid ? 0 : 1);
 }
+
 async function migrateEslintConfig(monorepoRoot, files) {
   const configBasePath = ".config/eslint";
   const existingConfigPath = node_path.join(monorepoRoot, "eslint.config.js");
@@ -1570,7 +907,7 @@ async function migrateEslintConfig(monorepoRoot, files) {
   try {
     existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
   } catch {
-    index.generateEslintConfigPackage(files);
+    workspace.renderEslintConfigPackage(files);
     return;
   }
   files[`${configBasePath}/package.json`] = {
@@ -1649,7 +986,7 @@ async function migratePrettierConfig(monorepoRoot, files) {
   try {
     existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
   } catch {
-    index.generatePrettierConfigPackage(files);
+    workspace.renderPrettierConfigPackage(files);
     return;
   }
   files[`${configBasePath}/package.json`] = {
@@ -1699,122 +1036,6 @@ Or in \`package.json\`:
     content: existingContent
   };
 }
-async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedSettings, scope) {
-  const workspaceDirectories = await parseWorkspaceDirectories(monorepoRoot);
-  const defaultDirectories = ["apps", "packages"];
-  const hasCustomDirectories = workspaceDirectories.length > 0 && !workspaceDirectories.every((dir) => defaultDirectories.includes(dir));
-  const packageType = await promptForInitialPackage();
-  if (packageType === "skip") {
-    return false;
-  }
-  const defaultDir = packageType === "app" ? "apps" : "packages";
-  const packageNameInput = await p__namespace.text({
-    message: "Package name?",
-    initialValue: `@${scope}/`,
-    validate: (value) => {
-      const validationError = index.validatePackageName(value);
-      if (validationError) return validationError;
-      const dirName = value.includes("/") ? value.split("/").pop() : value;
-      if (!dirName) return "Package name is required";
-      if (!hasCustomDirectories) {
-        const targetPath = node_path.join(monorepoRoot, defaultDir, dirName);
-        try {
-          const { statSync } = require$1("fs");
-          statSync(targetPath);
-          return `Directory ${defaultDir}/${dirName} already exists`;
-        } catch {
-        }
-      }
-    }
-  });
-  if (p__namespace.isCancel(packageNameInput)) {
-    return false;
-  }
-  const scopedName = packageNameInput;
-  const shortName = scopedName.includes("/") ? scopedName.split("/").pop() : scopedName;
-  const packageOptions = await promptForPackageOptions(scopedName, packageType, inheritedSettings);
-  let targetDir = defaultDir;
-  if (hasCustomDirectories && workspaceDirectories.length > 0) {
-    const dirChoice = await p__namespace.select({
-      message: "Target directory",
-      options: workspaceDirectories.map((dir) => ({
-        value: dir,
-        label: dir
-      })),
-      initialValue: workspaceDirectories.includes(defaultDir) ? defaultDir : workspaceDirectories[0]
-    });
-    if (p__namespace.isCancel(dirChoice)) {
-      return false;
-    }
-    targetDir = dirChoice;
-    const targetPath = node_path.join(monorepoRoot, targetDir, shortName);
-    try {
-      const { statSync } = require$1("fs");
-      statSync(targetPath);
-      p__namespace.log.error(`Directory ${targetDir}/${shortName} already exists`);
-      return false;
-    } catch {
-    }
-  }
-  const relativePkgPath = node_path.join(targetDir, shortName);
-  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
-  packageOptions.workspaceRoot = workspaceRoot;
-  packageOptions.name = scopedName;
-  packageOptions.packageManager = await index.resolvePackageManager(packageOptions);
-  packageOptions.engine = await index.resolveEngine(packageOptions);
-  packageOptions.versions = await index.resolveProjectPackageVersions(packageOptions);
-  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
-  if (workspacePackages.length > 0) {
-    const selectedDeps = await p__namespace.multiselect({
-      message: "Add workspace dependencies?",
-      options: workspacePackages.map((name) => ({ value: name, label: name })),
-      required: false
-    });
-    if (!p__namespace.isCancel(selectedDeps) && selectedDeps.length > 0) {
-      packageOptions.workspaceDependencies = selectedDeps;
-    }
-  }
-  const outputPath = node_path.join(monorepoRoot, relativePkgPath);
-  const spinner = p__namespace.spinner();
-  spinner.start("Creating package...");
-  try {
-    const files = index.generate(packageOptions);
-    await writeGeneratedFiles(outputPath, files);
-    spinner.stop(color__default.green.inverse(` \u2713 Package created at ${relativePkgPath}! `));
-    const addAnother = await p__namespace.select({
-      message: "Add another package?",
-      options: [
-        { value: "no", label: "No, I'm done" },
-        { value: "yes", label: "Yes, add another" }
-      ],
-      initialValue: "no"
-    });
-    return !p__namespace.isCancel(addAnother) && addAnother === "yes";
-  } catch (error) {
-    spinner.stop("Failed to create package");
-    p__namespace.log.error(String(error));
-    return false;
-  }
-}
-async function handleCheckCommand() {
-  const monorepoRoot = await detectMonorepoRoot();
-  if (!monorepoRoot) {
-    console.log(color__default.red("\u2717") + " Not a monorepo workspace");
-    process.exit(1);
-  }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
-  if (valid) {
-    console.log(color__default.green("\u2713") + " Valid monorepo workspace");
-    console.log(color__default.dim(`  ${monorepoRoot}`));
-  } else {
-    console.log(color__default.red("\u2717") + " Invalid monorepo workspace");
-    console.log(color__default.dim(`  ${monorepoRoot}`));
-    for (const error of errors) {
-      console.log(color__default.red(`  \u2022 ${error}`));
-    }
-  }
-  process.exit(valid ? 0 : 1);
-}
 async function handleFixCommand(options) {
   const monorepoRoot = await detectMonorepoRoot();
   if (!monorepoRoot) {
@@ -1896,48 +1117,48 @@ async function handleFixCommand(options) {
   spinner.start("Fixing workspace...");
   try {
     const files = {};
-    const tsConfigExists = await fileExists(
+    const tsConfigExists = await fileExists$1(
       node_path.join(monorepoRoot, ".config/typescript/package.json")
     );
     if (!tsConfigExists) {
-      index.generateTypescriptConfigPackage(files);
+      workspace.renderTypescriptConfigPackage(files);
     }
     if (linter === "oxlint") {
-      const oxlintExists = await fileExists(node_path.join(monorepoRoot, ".config/oxlint/package.json"));
-      if (!oxlintExists) index.generateOxlintConfigPackage(files);
+      const oxlintExists = await fileExists$1(node_path.join(monorepoRoot, ".config/oxlint/package.json"));
+      if (!oxlintExists) workspace.renderOxlintConfigPackage(files);
     } else if (linter === "eslint") {
-      const eslintPkgExists = await fileExists(
+      const eslintPkgExists = await fileExists$1(
         node_path.join(monorepoRoot, ".config/eslint/package.json")
       );
       if (!eslintPkgExists) {
         if (existingConfigs.eslintConfigPath) {
           await migrateEslintConfig(monorepoRoot, files);
         } else {
-          index.generateEslintConfigPackage(files);
+          workspace.renderEslintConfigPackage(files);
         }
       }
     }
     if (formatter === "oxfmt") {
-      const oxfmtExists = await fileExists(node_path.join(monorepoRoot, ".config/oxfmt/package.json"));
-      if (!oxfmtExists) index.generateOxfmtConfigPackage(files);
+      const oxfmtExists = await fileExists$1(node_path.join(monorepoRoot, ".config/oxfmt/package.json"));
+      if (!oxfmtExists) workspace.renderOxfmtConfigPackage(files);
     } else if (formatter === "prettier") {
-      const prettierPkgExists = await fileExists(
+      const prettierPkgExists = await fileExists$1(
         node_path.join(monorepoRoot, ".config/prettier/package.json")
       );
       if (!prettierPkgExists) {
         if (existingConfigs.prettierConfigPath) {
           await migratePrettierConfig(monorepoRoot, files);
         } else {
-          index.generatePrettierConfigPackage(files);
+          workspace.renderPrettierConfigPackage(files);
         }
       }
     }
     if ((linter === "biome" || formatter === "biome") && !existingConfigs.biomeConfigPath) {
-      const versions = await index.resolveMonorepoRootPackageVersions({
+      const versions = await workspace.resolveMonorepoRootPackageVersions({
         linter,
         formatter
       });
-      const biomeVersion = index.getResolvedPackageVersion(versions, "@biomejs/biome");
+      const biomeVersion = workspace.getResolvedPackageVersion(versions, "@biomejs/biome");
       const biomeConfig = {
         $schema: `https://biomejs.dev/schemas/${biomeVersion}/schema.json`,
         vcs: {
@@ -1979,13 +1200,13 @@ async function handleFixCommand(options) {
       }
     }
     spinner.stop(color__default.green("\u2713") + " Workspace fixed!");
-    const generated = Object.keys(files).filter((f) => f.endsWith("package.json"));
+    const generated = Object.keys(files).filter((file) => file.endsWith("package.json"));
     for (const pkgFile of generated) {
       const pkgName = pkgFile.replace("/package.json", "");
       console.log(color__default.dim(`  Generated ${pkgName}`));
     }
-    const vscodeSettingsExists = await fileExists(node_path.join(monorepoRoot, ".vscode/settings.json"));
-    const vscodeExtensionsExists = await fileExists(
+    const vscodeSettingsExists = await fileExists$1(node_path.join(monorepoRoot, ".vscode/settings.json"));
+    const vscodeExtensionsExists = await fileExists$1(
       node_path.join(monorepoRoot, ".vscode/extensions.json")
     );
     const vscodeExists = vscodeSettingsExists && vscodeExtensionsExists;
@@ -2002,7 +1223,7 @@ async function handleFixCommand(options) {
       }
       if (addVscode) {
         const vscodeFiles = {};
-        index.generateVscodeFiles(vscodeFiles, linter, formatter);
+        workspace.renderVscodeFiles(vscodeFiles, linter, formatter);
         for (const [filePath, file] of Object.entries(vscodeFiles)) {
           const fullPath = node_path.join(monorepoRoot, filePath);
           await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
@@ -2012,18 +1233,19 @@ async function handleFixCommand(options) {
         console.log(color__default.dim("  Generated .vscode/extensions.json"));
       }
     }
-    const aiRulesExist = await fileExists(node_path.join(monorepoRoot, ".ai/workspace.md"));
+    const aiRulesExist = await fileExists$1(node_path.join(monorepoRoot, ".ai/workspace.md"));
     if (!aiRulesExist) {
-      const platforms = await promptForAiPlatforms(isNonInteractive);
+      const platforms = await promptForAiAgentPlatforms(isNonInteractive);
       if (platforms.length > 0) {
         const scope = await getMonorepoScope(monorepoRoot);
         const aiFilesOutput = {};
-        index.generateAiFiles(aiFilesOutput, {
+        workspace.renderAiFiles(aiFilesOutput, {
           name: scope,
           packageManager: "pnpm",
           linter,
           formatter,
           isMonorepo: true,
+          hasTypecheck: false,
           platforms
         });
         for (const [filePath, file] of Object.entries(aiFilesOutput)) {
@@ -2041,290 +1263,780 @@ async function handleFixCommand(options) {
     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})`);
+
+async function detectCurrentConfig(root, isMonorepo = true) {
+  let name = root.split(/[/\\]/).pop() ?? "workspace";
+  let packageManager = "pnpm";
+  let hasTypecheck = false;
+  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(/\/.*$/, "");
     }
-  }
-  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);
+    if (pkgJson.packageManager) {
+      packageManager = pkgJson.packageManager.split("@")[0] ?? packageManager;
     }
+    hasTypecheck = pkgJson.scripts?.typecheck != null;
+  } catch {
   }
-  await applyMigration(plan, root);
-  const aiWorkspacePath = node_path.join(root, ".ai/workspace.md");
-  const aiRulesExist = await fileExists(aiWorkspacePath);
-  if (aiRulesExist) {
-    console.log();
-    console.log(color__default.cyan("Updating AI rules..."));
-    const scope = await getMonorepoScope(root);
-    const existingPlatforms = [];
-    if (await fileExists(node_path.join(root, "AGENTS.md"))) {
-      existingPlatforms.push("agents");
-    }
-    if (await fileExists(node_path.join(root, "CLAUDE.md"))) {
-      existingPlatforms.push("claude");
-    }
-    const aiFilesOutput = {};
-    index.generateAiFiles(aiFilesOutput, {
-      name: scope,
-      packageManager: "pnpm",
-      linter: plan.toLinter,
-      formatter: plan.toFormatter,
-      isMonorepo: true,
-      platforms: existingPlatforms.length > 0 ? existingPlatforms : ["agents"]
-    });
-    for (const [filePath, file] of Object.entries(aiFilesOutput)) {
-      const fullPath = node_path.join(root, filePath);
-      await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
-      await promises$1.writeFile(fullPath, file.content);
-      console.log(color__default.dim(`  ${filePath}`));
+  const tooling = await workspace.detectTooling(root);
+  const configStrategy = isMonorepo ? void 0 : await detectSinglePackageConfigStrategy(root);
+  return {
+    name,
+    linter: tooling.linter ?? "oxlint",
+    formatter: tooling.formatter ?? "prettier",
+    packageManager,
+    isMonorepo,
+    configStrategy,
+    hasTypecheck
+  };
+}
+async function detectSinglePackageConfigStrategy(root) {
+  const hasStealthConfig = await Promise.all([
+    fileExists(path.join(root, ".config/tsconfig.app.json")),
+    fileExists(path.join(root, ".config/tsconfig.node.json")),
+    fileExists(path.join(root, ".config/prettier.json")),
+    fileExists(path.join(root, ".config/oxlint.json"))
+  ]).then((matches) => matches.some(Boolean));
+  return hasStealthConfig ? "stealth" : "root";
+}
+async function planExpectedFiles(config) {
+  const { name, linter, formatter, packageManager, isMonorepo, configStrategy, hasTypecheck } = config;
+  const versions = linter === "biome" || formatter === "biome" ? await workspace.resolveMonorepoRootPackageVersions({ linter, formatter }) : {};
+  const aiFilesMap = {};
+  workspace.renderAiFiles(aiFilesMap, {
+    name,
+    packageManager,
+    linter,
+    formatter,
+    isMonorepo,
+    configStrategy,
+    hasTypecheck,
+    platforms: workspace.ALL_AI_PLATFORMS
+  });
+  const vscodeFiles = workspace.renderVscodeFiles$1({
+    linter,
+    formatter,
+    configStrategy,
+    isMonorepo,
+    packageManager: isPackageManagerName(packageManager) ? packageManager : void 0
+  });
+  const configPackages = {};
+  if (isMonorepo) {
+    workspace.renderTypescriptConfigPackage(configPackages);
+    if (linter === "oxlint") {
+      workspace.renderOxlintConfigPackage(configPackages);
+    } else if (linter === "eslint") {
+      workspace.renderEslintConfigPackage(configPackages);
+    }
+    if (formatter === "oxfmt") {
+      workspace.renderOxfmtConfigPackage(configPackages);
+    } else if (formatter === "prettier") {
+      workspace.renderPrettierConfigPackage(configPackages);
     }
   }
-  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);
+  const workspaceConfig = {};
+  const rootConfig = {};
+  rootConfig[".editorconfig"] = workspace.renderEditorConfig();
+  rootConfig[".gitignore"] = workspace.renderGitignore(isMonorepo ? "workspace-root" : "standalone");
+  rootConfig[".gitattributes"] = {
+    type: "text",
+    content: `* text=auto eol=lf
+*.{cmd,[cC][mM][dD]} text eol=crlf
+*.{bat,[bB][aA][tT]} text eol=crlf
+`
+  };
+  if (!isMonorepo && formatter === "prettier") {
+    rootConfig[configStrategy === "root" ? ".prettierignore" : ".config/prettierignore"] = {
+      type: "text",
+      content: workspace.toPrettierIgnoreContent()
+    };
+  }
+  if (linter === "biome" || formatter === "biome") {
+    const biomeVersion = workspace.getResolvedPackageVersion(versions, "@biomejs/biome");
+    const biomeConfig = {
+      $schema: `https://biomejs.dev/schemas/${biomeVersion}/schema.json`,
+      vcs: {
+        enabled: true,
+        clientKind: "git",
+        useIgnoreFile: true
+      },
+      linter: {
+        enabled: linter === "biome",
+        rules: {
+          recommended: true
+        }
+      },
+      formatter: {
+        enabled: formatter === "biome"
+      }
+    };
+    rootConfig["biome.json"] = {
+      type: "text",
+      content: JSON.stringify(biomeConfig, null, 2)
+    };
+  }
+  return {
+    "ai-files": aiFilesMap,
+    vscode: vscodeFiles,
+    "package-json": {},
+    "config-packages": configPackages,
+    "tooling-config": {},
+    "workspace-config": workspaceConfig,
+    "root-config": rootConfig
+  };
 }
-async function handleUpdateCommand(options) {
-  const monorepoRoot = await detectMonorepoRoot();
-  const projectRoot = monorepoRoot ?? await detectPackageRoot();
-  if (!projectRoot) {
-    console.log(color__default.red("\u2717") + " Could not find a project root");
-    console.log(color__default.dim("  Run this command from inside a generated project"));
-    process.exit(1);
+async function fileExists(path) {
+  try {
+    await promises.access(path, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
   }
-  const isMonorepo = monorepoRoot != null;
-  if (isMonorepo) {
-    const { valid, errors } = await validateWorkspace(projectRoot);
-    if (!valid) {
-      console.log(color__default.yellow("!") + " Workspace has issues:");
-      for (const error of errors) {
-        console.log(color__default.dim(`  \u2022 ${error}`));
+}
+function stripJsonComments(content) {
+  let output = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escaped = false;
+  for (let index = 0; index < content.length; index++) {
+    const char = content[index];
+    const next = content[index + 1];
+    if (inLineComment) {
+      if (char === "\n" || char === "\r") {
+        inLineComment = false;
+        output += char;
       }
-      console.log();
-      const shouldFix = options.yes || await p__namespace.confirm({
-        message: "Run fix first to resolve these issues?",
-        initialValue: true
-      });
-      if (p__namespace.isCancel(shouldFix) || !shouldFix) {
-        console.log(color__default.dim("  Run `pnpm create krispya --fix` to fix manually"));
-        process.exit(1);
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index++;
       }
-      const preFixConfig = await detectCurrentConfig(projectRoot);
-      const fixOptions = {
-        ...options,
-        linter: options.linter ?? preFixConfig.linter,
-        formatter: options.formatter ?? preFixConfig.formatter
-      };
-      await handleFixCommand(fixOptions);
+      continue;
     }
-  } else if (options.linter || options.formatter) {
-    console.log(
-      color__default.yellow("!") + " Linter/formatter migrations in --update are currently monorepo-only"
-    );
-    console.log(color__default.dim("  Continuing with standalone shared config updates"));
-    console.log();
-  }
-  const config = await detectCurrentConfig(projectRoot, isMonorepo);
-  const targetLinter = options.linter;
-  const targetFormatter = options.formatter;
-  const migrationTarget = { linter: targetLinter, formatter: targetFormatter };
-  if (isMonorepo && needsMigration(config, migrationTarget)) {
-    await handleMigration(config, migrationTarget, projectRoot, options);
-    return;
-  }
-  console.log(
-    color__default.cyan("Checking for updates...") + color__default.dim(` (${config.linter}/${config.formatter})`)
-  );
-  console.log();
-  const expected = await generateExpectedFiles(config);
-  const categories = await compareWithDisk(expected, projectRoot);
-  const allCategories = categories.filter((c) => c.category !== "workspace-config");
-  if (isMonorepo) {
-    const workspaceConfigChanges = await getWorkspaceConfigUpdates(projectRoot);
-    const workspaceCategory = {
-      category: "workspace-config",
-      label: "Workspace Config",
-      changes: workspaceConfigChanges,
-      hasUserModifications: workspaceConfigChanges.some((c) => c.status === "modified")
-    };
-    if (workspaceConfigChanges.length > 0) {
-      const configPkgIndex = allCategories.findIndex((c) => c.category === "config-packages");
-      if (configPkgIndex !== -1) {
-        allCategories.splice(configPkgIndex + 1, 0, workspaceCategory);
-      } else {
-        allCategories.push(workspaceCategory);
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
       }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      index++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      index++;
+      continue;
     }
+    output += char;
   }
-  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`);
+  return output;
+}
+function stripTrailingJsonCommas(content) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < content.length; index++) {
+    const char = content[index];
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
       continue;
     }
-    if (category.category === "ai-files") {
-      if (hasNew) {
-        console.log(color__default.cyan(category.label + ":"));
-        console.log(color__default.dim(`  ${newChanges.length} AI file(s) can be added`));
-        console.log();
-        const applyAi = options.yes ? true : await p__namespace.confirm({
-          message: "Add AI rules?",
-          initialValue: true
-        });
-        if (!p__namespace.isCancel(applyAi) && applyAi) {
-          await applyUpdates(newChanges, projectRoot);
-          console.log(color__default.green("\u2713") + ` Added ${newChanges.length} AI file(s)`);
-          updatedCount++;
-        } else {
-          console.log(color__default.dim(`  Skipped ${category.label}`));
-          skippedCount++;
-        }
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (/\s/.test(content[lookahead] ?? "")) lookahead++;
+      if (content[lookahead] === "}" || content[lookahead] === "]") {
+        continue;
       }
-      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)"));
+    }
+    output += char;
+  }
+  return output;
+}
+function parseJsonValue(content) {
+  return JSON.parse(stripTrailingJsonCommas(stripJsonComments(content)));
+}
+function stableJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(stableJsonValue);
+  }
+  if (value != null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, stableJsonValue(entryValue)])
+    );
+  }
+  return value;
+}
+function jsonValuesEqual(currentContent, newContent) {
+  try {
+    return JSON.stringify(stableJsonValue(parseJsonValue(currentContent))) === JSON.stringify(stableJsonValue(parseJsonValue(newContent)));
+  } catch {
+    return false;
+  }
+}
+function shouldCompareJsonValues(filePath) {
+  return filePath.endsWith(".json") || filePath.endsWith(".jsonc");
+}
+function fileContentsEqual(filePath, currentContent, newContent) {
+  if (shouldCompareJsonValues(filePath) && jsonValuesEqual(currentContent, newContent)) {
+    return true;
+  }
+  return currentContent === newContent;
+}
+async function compareWithDisk(expected, root) {
+  const categoryLabels = {
+    "ai-files": "AI Files",
+    "ai-files-install": "Install More AI Files",
+    "ai-files-update": "Update Existing AI Files",
+    vscode: "VS Code",
+    "package-json": "package.json Scripts",
+    "config-packages": "Config Packages",
+    "tooling-config": "Tooling Config",
+    "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(fullPath)) {
+        const currentContent = await promises.readFile(fullPath, "utf-8");
+        if (fileContentsEqual(filePath, currentContent, newContent)) {
+          changes.push({
+            path: filePath,
+            status: "unchanged",
+            currentContent,
+            newContent
+          });
         } else {
-          const updateExisting = await p__namespace.confirm({
-            message: "Update existing AI files to latest template?",
-            initialValue: false
+          changes.push({
+            path: filePath,
+            status: "modified",
+            currentContent,
+            newContent
           });
-          if (!p__namespace.isCancel(updateExisting) && updateExisting) {
-            await applyUpdates(modifiedChanges, projectRoot);
-            console.log(color__default.green("\u2713") + " Updated existing AI files");
-          }
         }
+      } else {
+        changes.push({
+          path: filePath,
+          status: "added",
+          newContent
+        });
+      }
+    }
+    if (category === "ai-files") {
+      const newAiFiles = changes.filter((change) => change.status === "added");
+      const modifiedAiFiles = changes.filter((change) => change.status === "modified");
+      if (newAiFiles.length > 0) {
+        categories.push({
+          category: "ai-files-install",
+          label: categoryLabels["ai-files-install"],
+          changes: newAiFiles,
+          hasUserModifications: false
+        });
+      }
+      if (modifiedAiFiles.length > 0) {
+        categories.push({
+          category: "ai-files-update",
+          label: categoryLabels["ai-files-update"],
+          changes: modifiedAiFiles,
+          hasUserModifications: true
+        });
       }
-      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));
+    if (changes.length === 0) continue;
+    const hasUserModifications = changes.some((c) => c.status === "modified");
+    categories.push({
+      category,
+      label: categoryLabels[category],
+      changes,
+      hasUserModifications
+    });
+  }
+  return categories;
+}
+function isPackageManagerName(value) {
+  return value === "pnpm" || value === "npm" || value === "yarn";
+}
+function hasPackage(pkg, name) {
+  return pkg.dependencies?.[name] != null || pkg.devDependencies?.[name] != null || pkg.peerDependencies?.[name] != null;
+}
+function sortPackageMap(packageMap) {
+  return Object.fromEntries(Object.entries(packageMap).sort(([a], [b]) => a.localeCompare(b)));
+}
+async function detectTypeScriptPackage(root, pkg) {
+  if (hasPackage(pkg, "typescript")) return true;
+  return await fileExists(path.join(root, "tsconfig.json")) || await fileExists(path.join(root, "tsconfig.app.json")) || await fileExists(path.join(root, ".config/tsconfig.app.json"));
+}
+function detectLibraryPackage(pkg) {
+  return pkg.exports != null || pkg.main?.includes("dist") === true || pkg.module?.includes("dist") === true || Array.isArray(pkg.files) && pkg.files.includes("dist");
+}
+function getPackageManagerForScripts(config, pkg) {
+  const packageManager = pkg.packageManager?.split("@")[0] ?? config.packageManager;
+  return isPackageManagerName(packageManager) ? packageManager : "pnpm";
+}
+function getSinglePackageToolScripts(config) {
+  const isStealth = (config.configStrategy ?? "stealth") === "stealth";
+  const linterScripts = config.linter === "oxlint" ? workspace.packageJsonScripts.lint.oxlint(isStealth ? ".config/oxlint.json" : void 0) : config.linter === "eslint" ? workspace.packageJsonScripts.lint.eslint(isStealth ? ".config/eslint.config.js" : void 0) : workspace.packageJsonScripts.lint.biome(isStealth ? ".config" : void 0);
+  const formatterScripts = config.formatter === "prettier" ? workspace.packageJsonScripts.format.prettier(
+    isStealth ? ".config/prettier.json" : void 0,
+    isStealth ? ".config/prettierignore" : void 0
+  ) : config.formatter === "oxfmt" ? workspace.packageJsonScripts.format.oxfmt(isStealth ? ".config/oxfmt.json" : "oxfmt.json") : workspace.packageJsonScripts.format.biome(isStealth ? ".config" : void 0);
+  return workspace.mergePackageJsonScripts(linterScripts, formatterScripts);
+}
+function getLibraryBuildScripts(pkg) {
+  if (!detectLibraryPackage(pkg)) return void 0;
+  if (hasPackage(pkg, "tsdown") || pkg.scripts?.build === "tsdown") {
+    return workspace.packageJsonScripts.build.tsdown;
+  }
+  return workspace.packageJsonScripts.build.unbuild();
+}
+function getTestingScripts(pkg) {
+  if (hasPackage(pkg, "vitest") || pkg.scripts?.test === "vitest") {
+    return workspace.packageJsonScripts.test.vitest;
+  }
+  return void 0;
+}
+function scriptsEqual(left, right) {
+  const leftEntries = Object.entries(left);
+  if (leftEntries.length !== Object.keys(right).length) return false;
+  return leftEntries.every(([key, value]) => right[key] === value);
+}
+async function getExpectedPackageScripts(root, config, pkg) {
+  if (config.isMonorepo) {
+    return workspace.packageJsonScripts.monorepoRoot(config.linter, config.formatter);
+  }
+  const language = await detectTypeScriptPackage(root, pkg) ? "typescript" : "javascript";
+  const isLibrary = detectLibraryPackage(pkg);
+  const packageManagerName = getPackageManagerForScripts(config, pkg);
+  return workspace.mergePackageJsonScripts(
+    workspace.resolveDefaultPackageJsonScripts({
+      language,
+      isLibrary,
+      packageManagerName
+    }),
+    getLibraryBuildScripts(pkg),
+    getTestingScripts(pkg),
+    getSinglePackageToolScripts(config)
+  );
+}
+async function getExpectedPackageDevDependencies(root, config, pkg) {
+  const nextDevDependencies = { ...pkg.devDependencies };
+  const shouldAddOxlintTypeAwareBackend = config.linter === "oxlint" && (config.isMonorepo || await detectTypeScriptPackage(root, pkg)) && !hasPackage(pkg, "oxlint-tsgolint");
+  if (shouldAddOxlintTypeAwareBackend) {
+    nextDevDependencies["oxlint-tsgolint"] = workspace.formatResolvedPackageVersion({}, "oxlint-tsgolint");
+  }
+  return sortPackageMap(nextDevDependencies);
+}
+async function getPackageJsonScriptUpdates(root, config) {
+  const packageJsonPath = path.join(root, "package.json");
+  let currentContent;
+  try {
+    currentContent = await promises.readFile(packageJsonPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const pkg = JSON.parse(currentContent);
+  const currentScripts = pkg.scripts ?? {};
+  const expectedScripts = await getExpectedPackageScripts(root, config, pkg);
+  const nextScripts = workspace.mergePackageJsonScripts(currentScripts, expectedScripts);
+  const currentDevDependencies = pkg.devDependencies ?? {};
+  const nextDevDependencies = await getExpectedPackageDevDependencies(root, config, pkg);
+  if (scriptsEqual(currentScripts, nextScripts) && scriptsEqual(currentDevDependencies, nextDevDependencies)) {
+    return [
+      {
+        path: "package.json",
+        status: "unchanged",
+        currentContent,
+        newContent: currentContent
       }
-      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)"));
-        }
+    ];
+  }
+  const nextPackageJson = {
+    ...pkg,
+    scripts: nextScripts
+  };
+  if (Object.keys(nextDevDependencies).length > 0 || pkg.devDependencies != null) {
+    nextPackageJson.devDependencies = nextDevDependencies;
+  }
+  const newContent = `${JSON.stringify(nextPackageJson, null, 2)}
+`;
+  return [
+    {
+      path: "package.json",
+      status: "modified",
+      currentContent,
+      newContent
+    }
+  ];
+}
+function planSinglePackageOxlintConfig(config) {
+  if (config.linter !== "oxlint" || config.isMonorepo) return void 0;
+  const isStealth = (config.configStrategy ?? "stealth") === "stealth";
+  const path = isStealth ? ".config/oxlint.json" : "oxlint.json";
+  const oxlintConfig = workspace.renderOxlintConfig({
+    schemaPath: isStealth ? "../node_modules/oxlint/configuration_schema.json" : "./node_modules/oxlint/configuration_schema.json",
+    typescript: true
+  });
+  return {
+    path,
+    status: "added",
+    newContent: `${JSON.stringify(oxlintConfig, null, 2)}
+`
+  };
+}
+async function getOxlintConfigReplacementUpdates(root, config) {
+  const expected = planSinglePackageOxlintConfig(config);
+  if (expected == null) return [];
+  const fullPath = path.join(root, expected.path);
+  let currentContent;
+  try {
+    currentContent = await promises.readFile(fullPath, "utf-8");
+  } catch {
+    return [expected];
+  }
+  if (fileContentsEqual(expected.path, currentContent, expected.newContent)) {
+    return [
+      {
+        ...expected,
+        status: "unchanged",
+        currentContent,
+        newContent: currentContent
       }
-    } 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
+    ];
+  }
+  return [
+    {
+      ...expected,
+      status: "modified",
+      currentContent
+    }
+  ];
+}
+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/*")) {
+    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 UPDATE_CATEGORY_ORDER = [
+  "root-config",
+  "config-packages",
+  "tooling-config",
+  "workspace-config",
+  "vscode",
+  "package-json",
+  "ai-files",
+  "ai-files-install",
+  "ai-files-update"
+];
+function isMergeUpdateCategory(category) {
+  return category === "workspace-config" || category === "package-json";
+}
+function getUpdateHint(category, status) {
+  if (status === "added") return "new file";
+  if (category === "package-json") return "merge update";
+  if (category === "workspace-config") return "merge update";
+  return "changed; overwrites if selected";
+}
+function isSelectableFileChange(change) {
+  return change.status === "added" || change.status === "modified";
+}
+function getInitialUpdateSelections(category) {
+  return category.changes.filter(
+    (change) => change.status === "added" || change.status === "modified" && isMergeUpdateCategory(category.category)
+  ).map((change) => change.path);
+}
+async function promptForUpdateSelections(category) {
+  const selectableChanges = category.changes.filter(isSelectableFileChange);
+  const selectedFiles = await p__namespace.multiselect({
+    message: category.label,
+    options: selectableChanges.map((change) => ({
+      value: change.path,
+      label: change.path,
+      hint: getUpdateHint(category.category, change.status)
+    })),
+    initialValues: getInitialUpdateSelections(category),
+    required: false
+  });
+  if (p__namespace.isCancel(selectedFiles)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return selectableChanges.filter((change) => selectedFiles.includes(change.path));
+}
+async function promptForAiFileInstall(category) {
+  const newChanges = category.changes.filter((change) => change.status === "added");
+  const fileList = newChanges.map((change) => change.path).join(", ");
+  const shouldInstall = await p__namespace.confirm({
+    message: fileList ? `Install more AI files? (${fileList})` : "Install more AI files?",
+    initialValue: true
+  });
+  if (p__namespace.isCancel(shouldInstall)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return shouldInstall ? newChanges : [];
+}
+function getCategoryOrder(category) {
+  const index = UPDATE_CATEGORY_ORDER.indexOf(category);
+  return index === -1 ? UPDATE_CATEGORY_ORDER.length : index;
+}
+function orderUpdateCategories(categories) {
+  return [...categories].sort(
+    (left, right) => getCategoryOrder(left.category) - getCategoryOrder(right.category)
+  );
+}
+async function collectUpdateCategories(projectRoot, config, isMonorepo) {
+  const expected = await planExpectedFiles(config);
+  const categories = await compareWithDisk(expected, projectRoot);
+  const allCategories = categories.filter((category) => category.category !== "workspace-config");
+  const packageJsonScriptChanges = await getPackageJsonScriptUpdates(projectRoot, config);
+  if (packageJsonScriptChanges.length > 0) {
+    allCategories.push({
+      category: "package-json",
+      label: "package.json",
+      changes: packageJsonScriptChanges,
+      hasUserModifications: packageJsonScriptChanges.some(
+        (change) => change.status === "modified"
+      )
+    });
+  }
+  const oxlintConfigChanges = await getOxlintConfigReplacementUpdates(projectRoot, config);
+  if (oxlintConfigChanges.length > 0) {
+    allCategories.push({
+      category: "tooling-config",
+      label: "Tooling Config",
+      changes: oxlintConfigChanges,
+      hasUserModifications: oxlintConfigChanges.some((change) => change.status === "modified")
+    });
+  }
+  if (isMonorepo) {
+    const workspaceConfigChanges = await getWorkspaceConfigUpdates(projectRoot);
+    if (workspaceConfigChanges.length > 0) {
+      allCategories.push({
+        category: "workspace-config",
+        label: "Workspace Config",
+        changes: workspaceConfigChanges,
+        hasUserModifications: workspaceConfigChanges.some(
+          (change) => change.status === "modified"
+        )
       });
-      if (p__namespace.isCancel(selectedFiles)) {
-        p__namespace.cancel("Operation cancelled.");
-        process.exit(0);
+    }
+  }
+  return orderUpdateCategories(allCategories);
+}
+async function processUpdateCategory(category, projectRoot, options) {
+  const newChanges = category.changes.filter((change) => change.status === "added");
+  const modifiedChanges = category.changes.filter((change) => change.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`);
+    return "unchanged";
+  }
+  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 (isMergeUpdateCategory(category.category)) {
+      changesToApply = [...newChanges, ...modifiedChanges];
+      if (changesToApply.length > 0) {
+        console.log(color__default.dim("  (--yes mode: applying merge updates)"));
       }
-      if (selectedFiles.length > 0) {
-        changesToApply = allChanges.filter((c) => selectedFiles.includes(c.path));
+    } else {
+      changesToApply = newChanges;
+      if (newChanges.length > 0) {
+        console.log(color__default.dim("  (--yes mode: adding new files only)"));
       }
-    } else if (hasNew) {
-      console.log(color__default.cyan(category.label + ":"));
-      for (const change of newChanges) {
-        console.log(formatFileChange(change));
+    }
+  } else {
+    changesToApply = category.category === "ai-files-install" ? await promptForAiFileInstall(category) : await promptForUpdateSelections(category);
+  }
+  if (changesToApply.length > 0) {
+    await applyUpdates(changesToApply, projectRoot);
+    const addedCount = changesToApply.filter((change) => change.status === "added").length;
+    const updatedFilesCount = changesToApply.filter(
+      (change) => change.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(", ")}`);
+    console.log();
+    return "updated";
+  }
+  console.log(color__default.dim(`  Skipped ${category.label}`));
+  console.log();
+  return "skipped";
+}
+async function handleUpdateCommand(options, handleFixCommand) {
+  const monorepoRoot = await detectMonorepoRoot();
+  const projectRoot = monorepoRoot ?? await detectPackageRoot();
+  if (!projectRoot) {
+    console.log(color__default.red("\u2717") + " Could not find a project root");
+    console.log(color__default.dim("  Run this command from inside a generated project"));
+    process.exit(1);
+  }
+  const isMonorepo = monorepoRoot != null;
+  if (isMonorepo) {
+    const { valid, errors } = await validateWorkspace(projectRoot);
+    if (!valid) {
+      console.log(color__default.yellow("!") + " Workspace has issues:");
+      for (const error of errors) {
+        console.log(color__default.dim(`  \u2022 ${error}`));
       }
       console.log();
-      const shouldAdd = await p__namespace.confirm({
-        message: `Add ${newChanges.length} new file(s)?`,
+      const shouldFix = options.yes || await p__namespace.confirm({
+        message: "Run fix first to resolve these issues?",
         initialValue: true
       });
-      if (p__namespace.isCancel(shouldAdd)) {
-        p__namespace.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (shouldAdd) {
-        changesToApply = newChanges;
-      }
-    } else if (hasModified) {
-      console.log(color__default.cyan(category.label + ":"));
-      for (const change of modifiedChanges) {
-        console.log(formatFileChange(change));
+      if (p__namespace.isCancel(shouldFix) || !shouldFix) {
+        console.log(color__default.dim("  Run `pnpm create krispya --fix` to fix manually"));
+        process.exit(1);
       }
-      console.log();
-      const shouldUpdate = await p__namespace.confirm({
-        message: `Update ${modifiedChanges.length} file(s)? (will overwrite)`,
-        initialValue: false
+      const preFixConfig = await detectCurrentConfig(projectRoot);
+      await handleFixCommand({
+        ...options,
+        linter: options.linter ?? preFixConfig.linter,
+        formatter: options.formatter ?? preFixConfig.formatter
       });
-      if (p__namespace.isCancel(shouldUpdate)) {
-        p__namespace.cancel("Operation cancelled.");
-        process.exit(0);
-      }
-      if (shouldUpdate) {
-        changesToApply = modifiedChanges;
-      }
-    }
-    if (changesToApply.length > 0) {
-      await applyUpdates(changesToApply, projectRoot);
-      const addedCount = changesToApply.filter((c) => c.status === "added").length;
-      const updatedFilesCount = changesToApply.filter((c) => c.status === "modified").length;
-      const parts = [];
-      if (addedCount > 0) parts.push(`added ${addedCount}`);
-      if (updatedFilesCount > 0) parts.push(`updated ${updatedFilesCount}`);
-      console.log(color__default.green("\u2713") + ` ${category.label}: ${parts.join(", ")}`);
-      updatedCount++;
-    } else {
-      console.log(color__default.dim(`  Skipped ${category.label}`));
-      skippedCount++;
     }
+  }
+  const config = await detectCurrentConfig(projectRoot, isMonorepo);
+  if (options.linter || options.formatter) {
+    console.log(
+      color__default.yellow("!") + " Linter/formatter migration is not part of --update in this architecture pass"
+    );
+    console.log(color__default.dim("  Continuing with updates for the detected current tooling"));
     console.log();
   }
+  console.log(
+    color__default.cyan("Checking for updates...") + color__default.dim(` (${config.linter}/${config.formatter})`)
+  );
+  console.log();
+  const categories = await collectUpdateCategories(projectRoot, config, isMonorepo);
+  let updatedCount = 0;
+  let skippedCount = 0;
+  for (const category of categories) {
+    const result = await processUpdateCategory(category, projectRoot, options);
+    if (result === "updated") updatedCount++;
+    if (result === "skipped") skippedCount++;
+  }
   if (updatedCount === 0 && skippedCount === 0) {
     console.log(color__default.green("\u2713") + " Everything is up to date!");
   } else if (updatedCount > 0) {
@@ -2337,7 +2049,103 @@ async function handleUpdateCommand(options) {
   }
   process.exit(0);
 }
-async function handleWorkspaceCommand(name, options) {
+
+const require$2 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
+async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedSettings, scope, writeGeneratedFiles) {
+  const workspaceDirectories = await parseWorkspaceDirectories(monorepoRoot);
+  const defaultDirectories = ["apps", "packages"];
+  const hasCustomDirectories = workspaceDirectories.length > 0 && !workspaceDirectories.every((dir) => defaultDirectories.includes(dir));
+  const packageType = await promptForInitialPackage();
+  if (packageType === "skip") {
+    return false;
+  }
+  const defaultDir = packageType === "app" ? "apps" : "packages";
+  const packageNameInput = await p__namespace.text({
+    message: "Package name?",
+    initialValue: `@${scope}/`,
+    validate: (value) => {
+      const validationError = workspace.validatePackageName(value);
+      if (validationError) return validationError;
+      const dirName = value.includes("/") ? value.split("/").pop() : value;
+      if (!dirName) return "Package name is required";
+      if (!hasCustomDirectories) {
+        const targetPath = node_path.join(monorepoRoot, defaultDir, dirName);
+        try {
+          const { statSync } = require$2("fs");
+          statSync(targetPath);
+          return `Directory ${defaultDir}/${dirName} already exists`;
+        } catch {
+        }
+      }
+    }
+  });
+  if (p__namespace.isCancel(packageNameInput)) {
+    return false;
+  }
+  const scopedName = packageNameInput;
+  const shortName = scopedName.includes("/") ? scopedName.split("/").pop() : scopedName;
+  const packageOptions = await promptForPackageOptions(scopedName, packageType, inheritedSettings);
+  let targetDir = defaultDir;
+  if (hasCustomDirectories && workspaceDirectories.length > 0) {
+    const dirChoice = await p__namespace.select({
+      message: "Target directory",
+      options: workspaceDirectories.map((dir) => ({
+        value: dir,
+        label: dir
+      })),
+      initialValue: workspaceDirectories.includes(defaultDir) ? defaultDir : workspaceDirectories[0]
+    });
+    if (p__namespace.isCancel(dirChoice)) {
+      return false;
+    }
+    targetDir = dirChoice;
+    const targetPath = node_path.join(monorepoRoot, targetDir, shortName);
+    try {
+      const { statSync } = require$2("fs");
+      statSync(targetPath);
+      p__namespace.log.error(`Directory ${targetDir}/${shortName} already exists`);
+      return false;
+    } catch {
+    }
+  }
+  const relativePkgPath = node_path.join(targetDir, shortName);
+  const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
+  packageOptions.workspaceRoot = workspaceRoot;
+  packageOptions.name = scopedName;
+  const workspacePackages = packageType === "app" ? await getWorkspacePackages(monorepoRoot) : [];
+  if (workspacePackages.length > 0) {
+    const selectedDeps = await p__namespace.multiselect({
+      message: "Add workspace dependencies?",
+      options: workspacePackages.map((name) => ({ value: name, label: name })),
+      required: false
+    });
+    if (!p__namespace.isCancel(selectedDeps) && selectedDeps.length > 0) {
+      packageOptions.workspaceDependencies = selectedDeps;
+    }
+  }
+  const outputPath = node_path.join(monorepoRoot, relativePkgPath);
+  const spinner = p__namespace.spinner();
+  spinner.start("Creating package...");
+  try {
+    const { files } = await workspace.planProject(workspace.resolveProjectPlanInput(packageOptions));
+    await writeGeneratedFiles(outputPath, files);
+    spinner.stop(color__default.green.inverse(` \u2713 Package created at ${relativePkgPath}! `));
+    const addAnother = await p__namespace.select({
+      message: "Add another package?",
+      options: [
+        { value: "no", label: "No, I'm done" },
+        { value: "yes", label: "Yes, add another" }
+      ],
+      initialValue: "no"
+    });
+    return !p__namespace.isCancel(addAnother) && addAnother === "yes";
+  } catch (error) {
+    spinner.stop("Failed to create package");
+    p__namespace.log.error(String(error));
+    return false;
+  }
+}
+async function handleWorkspaceCommand(name, options, writeGeneratedFiles) {
   const monorepoRoot = await detectMonorepoRoot();
   if (!monorepoRoot) {
     console.error(color__default.red("Error:") + " --workspace flag requires being inside a monorepo");
@@ -2354,7 +2162,7 @@ async function handleWorkspaceCommand(name, options) {
   const defaultDir = projectType === "library" ? "packages" : "apps";
   const targetDir = options.dir ?? defaultDir;
   const template = options.template ?? "vanilla";
-  const baseTemplate = index.getBaseTemplate(template);
+  const baseTemplate = workspace.getBaseTemplate(template);
   const scopedName = name.startsWith("@") ? name : `@${scope}/${name}`;
   const fullPackagePath = node_path.join(monorepoRoot, targetDir, name);
   try {
@@ -2374,7 +2182,7 @@ async function handleWorkspaceCommand(name, options) {
   const isLibrary = projectType === "library";
   const relativePkgPath = node_path.join(targetDir, name);
   const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
-  const generateOptions = {
+  const projectOptions = {
     name: scopedName,
     projectType,
     libraryBundler: isLibrary ? options.bundler ?? "unbuild" : void 0,
@@ -2400,12 +2208,9 @@ async function handleWorkspaceCommand(name, options) {
       triplex: options.triplex ? {} : void 0
     }
   };
-  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
-  generateOptions.engine = await index.resolveEngine(generateOptions);
-  generateOptions.versions = await index.resolveProjectPackageVersions(generateOptions);
   console.log(color__default.cyan("Creating") + ` ${scopedName} in ${targetDir}/${name}...`);
   try {
-    const files = index.generate(generateOptions);
+    const { files } = await workspace.planProject(workspace.resolveProjectPlanInput(projectOptions));
     await writeGeneratedFiles(fullPackagePath, files);
     console.log(color__default.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${name}`);
     process.exit(0);
@@ -2415,68 +2220,126 @@ async function handleWorkspaceCommand(name, options) {
     process.exit(1);
   }
 }
-async function handleMonorepoCreation(generateOptions, isNonInteractive) {
-  const { generateMonorepo } = await import('./chunks/index.cjs').then(function (n) { return n.monorepo; });
-  const packageManager = index.getPackageManagerName(generateOptions.packageManager);
-  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
-  generateOptions.engine = await index.resolveEngine(generateOptions);
-  generateOptions.versions = await index.resolveMonorepoRootPackageVersions({
-    linter: generateOptions.linter ?? "oxlint",
-    formatter: generateOptions.formatter ?? "prettier",
-    engine: generateOptions.engine,
-    versions: generateOptions.versions
+async function handleInteractiveMonorepoMode(monorepoRoot, writeGeneratedFiles) {
+  const choice = await p__namespace.select({
+    message: "Detected monorepo workspace",
+    options: [
+      { value: "add", label: "Add new package to this workspace" },
+      { value: "standalone", label: "Create single-package workspace" }
+    ],
+    initialValue: "add"
   });
-  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
-  const projectPath = node_path.join(node_process.cwd(), generateOptions.name);
+  if (p__namespace.isCancel(choice)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  if (choice === "add") {
+    const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
+    const hasSettings = Object.values(inheritedSettings).some(Boolean);
+    if (hasSettings) {
+      const settingsInfo = [
+        inheritedSettings.linter && `linter: ${inheritedSettings.linter}`,
+        inheritedSettings.formatter && `formatter: ${inheritedSettings.formatter}`,
+        inheritedSettings.packageManager && `pm: ${inheritedSettings.packageManager.name}`
+      ].filter(Boolean).join(", ");
+      p__namespace.log.info(`Using workspace settings (${settingsInfo})`);
+    }
+    const scope = await getMonorepoScope(monorepoRoot);
+    let addMore = true;
+    while (addMore) {
+      addMore = await createPackageInWorkspace(
+        monorepoRoot,
+        inheritedSettings.packageManager?.name ?? "pnpm",
+        inheritedSettings,
+        scope,
+        writeGeneratedFiles
+      );
+    }
+    p__namespace.note([`cd ${monorepoRoot}`, "pnpm install", "pnpm run dev"].join("\n"), "Next steps");
+    p__namespace.outro(color__default.green("Happy coding! \u2728"));
+    process.exit(0);
+  }
+}
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
+const pkg = require$1("../package.json");
+const META_OPTIONS = [
+  "clearConfig",
+  "configPath",
+  "check",
+  "fix",
+  "update",
+  "yes",
+  "workspace",
+  "path",
+  "dir"
+];
+function hasConfigOptions(options) {
+  return Object.keys(options).some(
+    (key) => !META_OPTIONS.includes(key)
+  );
+}
+async function writeGeneratedFiles(basePath, files) {
+  const filePaths = Object.keys(files).sort();
+  for (const filePath of filePaths) {
+    const fullFilePath = node_path.join(basePath, filePath);
+    await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
+    const file = files[filePath];
+    if (file.type === "text") {
+      await promises$1.writeFile(fullFilePath, file.content);
+    } else {
+      const response = await undici.fetch(file.url);
+      await promises$1.writeFile(fullFilePath, response.body);
+    }
+  }
+}
+async function handleMonorepoCreation(projectOptions, isNonInteractive) {
+  const packageManager = workspace.getPackageManagerName(projectOptions.packageManager);
+  const projectPath = node_path.join(node_process.cwd(), projectOptions.name);
   const spinner = p__namespace.spinner();
   spinner.start("Creating monorepo workspace...");
   try {
-    const { files } = generateMonorepo({
-      name: generateOptions.name,
-      linter: generateOptions.linter ?? "oxlint",
-      formatter: generateOptions.formatter ?? "prettier",
-      packageManager: generateOptions.packageManager ?? {
+    const planInput = workspace.resolveWorkspacePlanInput({
+      name: projectOptions.name,
+      linter: projectOptions.linter ?? "oxlint",
+      formatter: projectOptions.formatter ?? "prettier",
+      packageManager: projectOptions.packageManager ?? {
         name: packageManager
       },
-      pnpmManageVersions: generateOptions.pnpmManageVersions,
-      engine: generateOptions.engine,
-      versions: generateOptions.versions,
-      aiPlatforms: aiPlatforms.length > 0 ? aiPlatforms : void 0
+      pnpmManageVersions: projectOptions.pnpmManageVersions,
+      engine: projectOptions.engine,
+      versions: projectOptions.versions,
+      aiPlatforms: projectOptions.aiPlatforms,
+      ide: projectOptions.ide ?? "vscode"
     });
-    const filePaths = Object.keys(files).sort();
-    for (const filePath of filePaths) {
-      const fullFilePath = node_path.join(projectPath, filePath);
-      await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
-      const file = files[filePath];
-      if (file.type === "text") {
-        await promises$1.writeFile(fullFilePath, file.content);
-      }
-    }
+    const { files } = await workspace.planWorkspace(planInput);
+    await writeGeneratedFiles(projectPath, files);
     spinner.stop(color__default.green.inverse(" \u2713 Monorepo workspace created! "));
     if (isNonInteractive) {
       process.exit(0);
     }
     const newWorkspaceSettings = {
-      linter: generateOptions.linter,
-      formatter: generateOptions.formatter,
-      packageManager: generateOptions.packageManager ?? {
+      linter: projectOptions.linter,
+      formatter: projectOptions.formatter,
+      packageManager: projectOptions.packageManager ?? {
         name: packageManager
       },
-      engine: generateOptions.engine,
-      pnpmManageVersions: generateOptions.pnpmManageVersions
+      engine: projectOptions.engine,
+      pnpmManageVersions: projectOptions.pnpmManageVersions
     };
-    const scope = generateOptions.name;
+    const scope = projectOptions.name;
     let addMore = true;
     while (addMore) {
       addMore = await createPackageInWorkspace(
         projectPath,
         packageManager,
         newWorkspaceSettings,
-        scope
+        scope,
+        writeGeneratedFiles
       );
     }
     const nextSteps = [
-      `cd ${generateOptions.name}`,
+      `cd ${projectOptions.name}`,
       `${packageManager} install`,
       `${packageManager} run dev`
     ].join("\n");
@@ -2489,33 +2352,26 @@ async function handleMonorepoCreation(generateOptions, isNonInteractive) {
     process.exit(1);
   }
 }
-async function handleStandaloneProjectCreation(generateOptions, isNonInteractive) {
-  const base = generateOptions.template ? index.getBaseTemplate(generateOptions.template) : "vanilla";
+async function handleSingleWorkspaceCreation(projectOptions, isNonInteractive) {
+  const base = projectOptions.template ? workspace.getBaseTemplate(projectOptions.template) : "vanilla";
   const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
-  generateOptions.name ??= defaultFallbackName;
-  const aiPlatforms = await promptForAiPlatforms(isNonInteractive);
-  if (aiPlatforms.length > 0) {
-    generateOptions.aiPlatforms = aiPlatforms;
-  }
-  const packageManager = index.getPackageManagerName(generateOptions.packageManager);
-  const isLibrary = generateOptions.projectType === "library";
-  generateOptions.packageManager = await index.resolvePackageManager(generateOptions);
-  generateOptions.engine = await index.resolveEngine(generateOptions);
-  generateOptions.versions = await index.resolveProjectPackageVersions(generateOptions);
-  const projectPath = node_path.join(node_process.cwd(), generateOptions.name);
+  projectOptions.name ??= defaultFallbackName;
+  const packageManager = workspace.getPackageManagerName(projectOptions.packageManager);
+  const projectPath = node_path.join(node_process.cwd(), projectOptions.name);
   const spinner = p__namespace.spinner();
   spinner.start("Creating project...");
   try {
-    const files = index.generate(generateOptions);
+    const planInput = workspace.resolveProjectPlanInput(projectOptions);
+    const { files } = await workspace.planProject(planInput);
     await writeGeneratedFiles(projectPath, files);
     spinner.stop(color__default.green.inverse(" \u2713 Project created! "));
     if (isNonInteractive) process.exit(0);
-    const nextSteps = isLibrary ? [
-      `cd ${generateOptions.name}`,
+    const nextSteps = projectOptions.projectType === "library" ? [
+      `cd ${projectOptions.name}`,
       `${packageManager} install`,
       `${packageManager} run build`
     ].join("\n") : [
-      `cd ${generateOptions.name}`,
+      `cd ${projectOptions.name}`,
       `${packageManager} install`,
       `${packageManager} run dev`
     ].join("\n");
@@ -2527,45 +2383,6 @@ async function handleStandaloneProjectCreation(generateOptions, isNonInteractive
     process.exit(1);
   }
 }
-async function handleInteractiveMonorepoMode(monorepoRoot) {
-  const choice = await p__namespace.select({
-    message: "Detected monorepo workspace",
-    options: [
-      { value: "add", label: "Add new package to this workspace" },
-      { value: "standalone", label: "Create standalone project" }
-    ],
-    initialValue: "add"
-  });
-  if (p__namespace.isCancel(choice)) {
-    p__namespace.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (choice === "add") {
-    const inheritedSettings = await detectWorkspaceSettings(monorepoRoot);
-    const hasSettings = Object.values(inheritedSettings).some(Boolean);
-    if (hasSettings) {
-      const settingsInfo = [
-        inheritedSettings.linter && `linter: ${inheritedSettings.linter}`,
-        inheritedSettings.formatter && `formatter: ${inheritedSettings.formatter}`,
-        inheritedSettings.packageManager && `pm: ${inheritedSettings.packageManager.name}`
-      ].filter(Boolean).join(", ");
-      p__namespace.log.info(`Using workspace settings (${settingsInfo})`);
-    }
-    const scope = await getMonorepoScope(monorepoRoot);
-    let addMore = true;
-    while (addMore) {
-      addMore = await createPackageInWorkspace(
-        monorepoRoot,
-        inheritedSettings.packageManager?.name ?? "pnpm",
-        inheritedSettings,
-        scope
-      );
-    }
-    p__namespace.note([`cd ${monorepoRoot}`, "pnpm install", "pnpm run dev"].join("\n"), "Next steps");
-    p__namespace.outro(color__default.green("Happy coding! \u2728"));
-    process.exit(0);
-  }
-}
 async function main() {
   const program = new commander.Command().name("create-krispya").description("CLI for creating Vanilla, React, and React Three Fiber projects").argument("[name]", "name for the project").option("--type <type>", "project type: app or library (default: app)").option(
     "--bundler <bundler>",
@@ -2573,7 +2390,7 @@ async function main() {
   ).option(
     "--template <type>",
     "project template: vanilla, vanilla-js, react, react-js, r3f, r3f-js (default: vanilla)"
-  ).option("--linter <type>", "linter: eslint, oxlint, or biome (default: oxlint)").option("--formatter <type>", "formatter: prettier, oxfmt, or biome (default: prettier)").option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option("--package-manager <manager>", "specify package manager (e.g. npm, yarn, pnpm)").option(
+  ).option("--linter <type>", "linter: eslint, oxlint, or biome (default: oxlint)").option("--formatter <type>", "formatter: prettier, oxfmt, or biome (default: prettier)").option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option("--package-manager <manager>", "specify package manager (e.g. npm, yarn, pnpm)").option("--ide <ide>", "IDE files: vscode or none (default: vscode)").option(
     "--pnpm-manage-versions",
     "enable manage-package-manager-versions in pnpm-workspace.yaml (default: true)"
   ).option(
@@ -2598,6 +2415,10 @@ async function main() {
       console.log(getConfigPath());
       process.exit(0);
     }
+    if (options.ide && !["vscode", "none"].includes(options.ide)) {
+      console.error(color__default.red("Error:") + ' --ide must be "vscode" or "none"');
+      process.exit(1);
+    }
     if (name?.startsWith("-")) {
       switch (name) {
         case "--version":
@@ -2639,7 +2460,7 @@ async function main() {
       await handleFixCommand(options);
     }
     if (options.update) {
-      await handleUpdateCommand(options);
+      await handleUpdateCommand(options, handleFixCommand);
     }
     if (options.dir && !options.workspace) {
       console.error(color__default.red("Error:") + " --dir requires --workspace flag");
@@ -2649,27 +2470,28 @@ async function main() {
       process.exit(1);
     }
     if (options.workspace) {
-      await handleWorkspaceCommand(name, options);
+      await handleWorkspaceCommand(name, options, writeGeneratedFiles);
     }
     console.clear();
     p__namespace.intro(color__default.bgCyan(color__default.black(` create-krispya v${pkg.version} `)));
     const monorepoRoot = await detectMonorepoRoot();
     if (monorepoRoot && !hasConfigOptions(options)) {
-      await handleInteractiveMonorepoMode(monorepoRoot);
+      await handleInteractiveMonorepoMode(monorepoRoot, writeGeneratedFiles);
     }
-    let generateOptions;
+    let projectOptions;
     if (options.yes) {
       const template = options.template ?? "vanilla";
-      const baseTemplate = index.getBaseTemplate(template);
+      const baseTemplate = workspace.getBaseTemplate(template);
       const defaultName = getDefaultProjectName(template);
       const projectType = options.type ?? "app";
-      generateOptions = {
+      projectOptions = {
         name: name || defaultName,
         projectType,
         libraryBundler: projectType === "library" ? options.bundler ?? "unbuild" : void 0,
         template,
         linter: options.linter ?? "oxlint",
         formatter: options.formatter ?? "prettier",
+        ide: options.ide ?? "vscode",
         ...baseTemplate === "r3f" && {
           drei: options.drei ? {} : void 0,
           handle: options.handle ? {} : void 0,
@@ -2696,6 +2518,7 @@ async function main() {
         linter: options.linter,
         formatter: options.formatter,
         packageManager: options.packageManager,
+        ide: options.ide,
         engine: options.nodeVersion ? { name: "node", version: options.nodeVersion } : void 0,
         pnpmManageVersions: options.pnpmManageVersions,
         drei: options.drei,
@@ -2711,13 +2534,17 @@ async function main() {
         triplex: options.triplex,
         viverse: options.viverse
       } : void 0;
-      generateOptions = await promptForOptions(name, presets);
+      projectOptions = await promptForOptions(name, presets);
     }
     const isNonInteractive = options.yes ?? false;
-    if (generateOptions.projectType === "monorepo") {
-      await handleMonorepoCreation(generateOptions, isNonInteractive);
+    const aiAgentPlatforms = await promptForAiAgentPlatforms(isNonInteractive);
+    if (aiAgentPlatforms.length > 0) {
+      projectOptions.aiPlatforms = aiAgentPlatforms;
+    }
+    if (projectOptions.projectType === "monorepo") {
+      await handleMonorepoCreation(projectOptions, isNonInteractive);
     } else {
-      await handleStandaloneProjectCreation(generateOptions, isNonInteractive);
+      await handleSingleWorkspaceCreation(projectOptions, isNonInteractive);
     }
   });
   await program.parseAsync();