uilint 0.2.13 → 0.2.15

package/dist/{install-ui-ITXPOUVQ.js → install-ui-73AINMZ5.js}

@@ -7,13 +7,14 @@ import {
   multiselect,
   note,
   pc,
-  printBox,
   select
-} from "./chunk-EYCSOCU4.js";
+} from "./chunk-FRNXXIEM.js";
 import {
   GENSTYLEGUIDE_COMMAND_MD,
+  detectPackageManager,
+  installDependencies,
   loadSkill
-} from "./chunk-2RNDQVEK.js";
+} from "./chunk-PBEKMDUH.js";
 
 // src/commands/install-ui.tsx
 import { render } from "ink";
@@ -141,6 +142,9 @@ function StatusIndicator({ status, isSelected }) {
   if (status === "installed") {
     return /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" });
   }
+  if (status === "upgradeable") {
+    return isSelected ? /* @__PURE__ */ jsx3(Text3, { color: "blue", children: "\u2B06" }) : /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" });
+  }
   if (isSelected || status === "selected") {
     return /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u25C9" });
   }
@@ -153,6 +157,9 @@ function StatusLabel({ status }) {
   if (status === "installed") {
     return /* @__PURE__ */ jsx3(Text3, { color: "green", dimColor: true, children: "installed" });
   }
+  if (status === "upgradeable") {
+    return /* @__PURE__ */ jsx3(Text3, { color: "blue", dimColor: true, children: "upgrade available" });
+  }
   if (status === "partial") {
     return /* @__PURE__ */ jsx3(Text3, { color: "yellow", dimColor: true, children: "partial" });
   }
@@ -178,7 +185,8 @@ function ConfigSelector({
   const flatItems = items;
   const handleToggle = useCallback(() => {
     const item = flatItems[cursor];
-    if (!item || item.disabled || item.status === "installed") return;
+    const canToggle = item && !item.disabled && item.status !== "installed";
+    if (!canToggle) return;
     setSelected((prev) => {
       const next = new Set(prev);
       if (next.has(item.id)) {
@@ -519,6 +527,15 @@ function getAllInstallers() {
 
 // src/commands/install/components/InstallApp.tsx
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function getTargetStatus(target) {
+  if (!target.isInstalled) {
+    return "not_installed";
+  }
+  if (target.canUpgrade) {
+    return "upgradeable";
+  }
+  return "installed";
+}
 function buildConfigItemsForProject(project, selectedProject, selections) {
   const items = [];
   for (const selection of selections) {
@@ -546,7 +563,7 @@ function buildConfigItemsForProject(project, selectedProject, selections) {
         id: `${installer.id}:${target.id}`,
         label: installer.name,
         hint: target.hint,
-        status: target.isInstalled ? "installed" : "not_installed",
+        status: getTargetStatus(target),
         category: info.category,
         categoryIcon: info.icon
       });
@@ -571,7 +588,7 @@ function buildGlobalConfigItems(selections) {
         id: `${installer.id}:${target.id}`,
         label: installer.name,
         hint: target.hint,
-        status: target.isInstalled ? "installed" : "not_installed",
+        status: getTargetStatus(target),
         category: info.category,
         categoryIcon: info.icon
       });
@@ -653,11 +670,13 @@ function InstallApp({
       const installers2 = getAllInstallers();
       const initialSelections = installers2.filter((installer) => installer.isApplicable(proj)).map((installer) => {
         const targets = installer.getTargets(proj);
-        const nonInstalledTargets = targets.filter((t) => !t.isInstalled);
+        const actionableTargets = targets.filter(
+          (t) => !t.isInstalled || t.canUpgrade
+        );
         return {
           installer,
           targets,
-          selected: nonInstalledTargets.length > 0
+          selected: actionableTargets.length > 0
         };
       });
       setSelections(initialSelections);
@@ -798,8 +817,8 @@ function InstallApp({
 }
 
 // src/commands/install/analyze.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 import { findWorkspaceRoot as findWorkspaceRoot2 } from "uilint-core/node";
 
 // src/utils/vite-detect.ts
@@ -1043,86 +1062,16 @@ function findPackages(rootDir, options) {
   });
 }
 
-// src/utils/package-manager.ts
-import { existsSync as existsSync3 } from "fs";
-import { spawn } from "child_process";
-import { dirname, join as join3 } from "path";
-function detectExecutionPackageManager() {
-  const userAgent = process.env.npm_config_user_agent;
-  if (userAgent) {
-    if (userAgent.startsWith("pnpm/")) return "pnpm";
-    if (userAgent.startsWith("yarn/")) return "yarn";
-    if (userAgent.startsWith("bun/")) return "bun";
-    if (userAgent.startsWith("npm/")) return "npm";
-  }
-  const execPath = process.env.npm_execpath;
-  if (execPath) {
-    if (execPath.includes("pnpm")) return "pnpm";
-    if (execPath.includes("yarn")) return "yarn";
-    if (execPath.includes("bun")) return "bun";
-    if (execPath.includes("npm")) return "npm";
-  }
-  return null;
-}
-function detectPackageManager(projectPath) {
-  let dir = projectPath;
-  for (; ; ) {
-    if (existsSync3(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync3(join3(dir, "pnpm-workspace.yaml"))) return "pnpm";
-    if (existsSync3(join3(dir, "yarn.lock"))) return "yarn";
-    if (existsSync3(join3(dir, "bun.lockb"))) return "bun";
-    if (existsSync3(join3(dir, "bun.lock"))) return "bun";
-    if (existsSync3(join3(dir, "package-lock.json"))) return "npm";
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return "npm";
-}
-function spawnAsync(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve();
-      else
-        reject(new Error(`${command} ${args.join(" ")} exited with ${code}`));
-    });
-  });
-}
-async function installDependencies(pm, projectPath, packages) {
-  if (!packages.length) return;
-  switch (pm) {
-    case "pnpm":
-      await spawnAsync("pnpm", ["add", ...packages], projectPath);
-      return;
-    case "yarn":
-      await spawnAsync("yarn", ["add", ...packages], projectPath);
-      return;
-    case "bun":
-      await spawnAsync("bun", ["add", ...packages], projectPath);
-      return;
-    case "npm":
-    default:
-      await spawnAsync("npm", ["install", "--save", ...packages], projectPath);
-      return;
-  }
-}
-
 // src/utils/eslint-config-inject.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { join as join4, relative as relative2, dirname as dirname2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join3, relative as relative2, dirname } from "path";
 import { parseExpression, parseModule, generateCode } from "magicast";
 import { findWorkspaceRoot } from "uilint-core/node";
 var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
 function findEslintConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS) {
-    const configPath = join4(projectPath, `eslint.config${ext}`);
-    if (existsSync4(configPath)) {
+    const configPath = join3(projectPath, `eslint.config${ext}`);
+    if (existsSync3(configPath)) {
       return configPath;
     }
   }
@@ -1345,8 +1294,8 @@ function chooseUniqueIdentifier(base, used) {
 function addLocalRuleImportsAst(mod, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
   const importNames = /* @__PURE__ */ new Map();
   let changed = false;
-  const configDir = dirname2(configPath);
-  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const configDir = dirname(configPath);
+  const rulesDir = join3(rulesRoot, ".uilint", "rules");
   const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
   const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
   const used = collectTopLevelBindings(mod.$ast);
@@ -1373,8 +1322,8 @@ function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot,
   if (!program || program.type !== "Program") {
     return { importNames, changed };
   }
-  const configDir = dirname2(configPath);
-  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const configDir = dirname(configPath);
+  const rulesDir = join3(rulesRoot, ".uilint", "rules");
   const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
   const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
   const used = collectTopLevelBindings(program);
@@ -1585,10 +1534,10 @@ async function installEslintPlugin(opts) {
     };
   }
   let modifiedAst = false;
-  const localRulesDir = join4(opts.projectPath, ".uilint", "rules");
+  const localRulesDir = join3(opts.projectPath, ".uilint", "rules");
   const workspaceRoot = findWorkspaceRoot(opts.projectPath);
-  const workspaceRulesDir = join4(workspaceRoot, ".uilint", "rules");
-  const rulesRoot = existsSync4(localRulesDir) ? opts.projectPath : workspaceRoot;
+  const workspaceRulesDir = join3(workspaceRoot, ".uilint", "rules");
+  const rulesRoot = existsSync3(localRulesDir) ? opts.projectPath : workspaceRoot;
   const isTypeScriptConfig = configPath.endsWith(".ts");
   let fileExtension = isTypeScriptConfig ? "" : ".js";
   let ruleImportNames;
@@ -1663,12 +1612,12 @@ async function installEslintPlugin(opts) {
 async function analyze(projectPath = process.cwd()) {
   const workspaceRoot = findWorkspaceRoot2(projectPath);
   const packageManager = detectPackageManager(projectPath);
-  const cursorDir = join5(projectPath, ".cursor");
-  const cursorDirExists = existsSync5(cursorDir);
-  const styleguidePath = join5(projectPath, ".uilint", "styleguide.md");
-  const styleguideExists = existsSync5(styleguidePath);
-  const commandsDir = join5(cursorDir, "commands");
-  const genstyleguideExists = existsSync5(join5(commandsDir, "genstyleguide.md"));
+  const cursorDir = join4(projectPath, ".cursor");
+  const cursorDirExists = existsSync4(cursorDir);
+  const styleguidePath = join4(projectPath, ".uilint", "styleguide.md");
+  const styleguideExists = existsSync4(styleguidePath);
+  const commandsDir = join4(cursorDir, "commands");
+  const genstyleguideExists = existsSync4(join4(commandsDir, "genstyleguide.md"));
   const nextApps = [];
   const directDetection = detectNextAppRouter(projectPath);
   if (directDetection) {
@@ -1742,7 +1691,7 @@ async function analyze(projectPath = process.cwd()) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync10,
   mkdirSync,
   writeFileSync as writeFileSync5,
   readFileSync as readFileSync8,
@@ -1752,39 +1701,39 @@ import {
 import { dirname as dirname4 } from "path";
 
 // src/utils/react-inject.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, relative as relative3 } from "path";
 import { parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
 function getDefaultCandidates(projectPath, appRoot) {
   const viteMainCandidates = [
-    join6(appRoot, "main.tsx"),
-    join6(appRoot, "main.jsx"),
-    join6(appRoot, "main.ts"),
-    join6(appRoot, "main.js")
+    join5(appRoot, "main.tsx"),
+    join5(appRoot, "main.jsx"),
+    join5(appRoot, "main.ts"),
+    join5(appRoot, "main.js")
   ];
   const existingViteMain = viteMainCandidates.filter(
-    (rel) => existsSync6(join6(projectPath, rel))
+    (rel) => existsSync5(join5(projectPath, rel))
   );
   if (existingViteMain.length > 0) return existingViteMain;
-  const viteAppCandidates = [join6(appRoot, "App.tsx"), join6(appRoot, "App.jsx")];
+  const viteAppCandidates = [join5(appRoot, "App.tsx"), join5(appRoot, "App.jsx")];
   const existingViteApp = viteAppCandidates.filter(
-    (rel) => existsSync6(join6(projectPath, rel))
+    (rel) => existsSync5(join5(projectPath, rel))
   );
   if (existingViteApp.length > 0) return existingViteApp;
   const layoutCandidates = [
-    join6(appRoot, "layout.tsx"),
-    join6(appRoot, "layout.jsx"),
-    join6(appRoot, "layout.ts"),
-    join6(appRoot, "layout.js")
+    join5(appRoot, "layout.tsx"),
+    join5(appRoot, "layout.jsx"),
+    join5(appRoot, "layout.ts"),
+    join5(appRoot, "layout.js")
   ];
   const existingLayouts = layoutCandidates.filter(
-    (rel) => existsSync6(join6(projectPath, rel))
+    (rel) => existsSync5(join5(projectPath, rel))
   );
   if (existingLayouts.length > 0) {
     return existingLayouts;
   }
-  const pageCandidates = [join6(appRoot, "page.tsx"), join6(appRoot, "page.jsx")];
-  return pageCandidates.filter((rel) => existsSync6(join6(projectPath, rel)));
+  const pageCandidates = [join5(appRoot, "page.tsx"), join5(appRoot, "page.jsx")];
+  return pageCandidates.filter((rel) => existsSync5(join5(projectPath, rel)));
 }
 function isUseClientDirective(stmt) {
   return stmt?.type === "ExpressionStatement" && stmt.expression?.type === "StringLiteral" && stmt.expression.value === "use client";
@@ -1810,6 +1759,32 @@ function walkAst(node, visit) {
     }
   }
 }
+function ensureNamedImport(program, from, name) {
+  if (!program || program.type !== "Program") return { changed: false };
+  const existing = findImportDeclaration(program, from);
+  if (existing) {
+    const has = (existing.specifiers ?? []).some(
+      (s) => s?.type === "ImportSpecifier" && (s.imported?.name === name || s.imported?.value === name)
+    );
+    if (has) return { changed: false };
+    const spec = parseModule2(`import { ${name} } from "${from}";`).$ast.body?.[0]?.specifiers?.[0];
+    if (!spec) return { changed: false };
+    existing.specifiers = [...existing.specifiers ?? [], spec];
+    return { changed: true };
+  }
+  const importDecl = parseModule2(`import { ${name} } from "${from}";`).$ast.body?.[0];
+  if (!importDecl) return { changed: false };
+  const body = program.body ?? [];
+  let insertAt = 0;
+  while (insertAt < body.length && isUseClientDirective(body[insertAt])) {
+    insertAt++;
+  }
+  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
+    insertAt++;
+  }
+  program.body.splice(insertAt, 0, importDecl);
+  return { changed: true };
+}
 function hasUILintDevtoolsJsx(program) {
   let found = false;
   walkAst(program, (node) => {
@@ -1903,7 +1878,204 @@ function ensureSideEffectImport(program, from) {
   program.body.splice(insertAt, 0, importDecl);
   return { changed: true };
 }
+function addDevtoolsToClientComponent(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  if (hasUILintDevtoolsJsx(program)) return { changed: false };
+  const devtoolsMod = parseModule2(
+    "const __uilint_devtools = (<uilint-devtools />);"
+  );
+  const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+  if (!devtoolsJsx || devtoolsJsx.type !== "JSXElement")
+    return { changed: false };
+  let added = false;
+  walkAst(program, (node) => {
+    if (added) return;
+    if (node.type !== "JSXElement" && node.type !== "JSXFragment") return;
+    const children = node.children ?? [];
+    const childrenIndex = children.findIndex(
+      (child) => child?.type === "JSXExpressionContainer" && child.expression?.type === "Identifier" && child.expression.name === "children"
+    );
+    if (childrenIndex !== -1) {
+      children.splice(childrenIndex + 1, 0, devtoolsJsx);
+      added = true;
+    }
+  });
+  if (added) return { changed: true };
+  walkAst(program, (node) => {
+    if (added) return;
+    if (node.type !== "ReturnStatement") return;
+    const arg = node.argument;
+    if (!arg) return;
+    if (arg.type !== "JSXElement" && arg.type !== "JSXFragment") return;
+    const fragmentMod = parseModule2("const __fragment = (<></>);");
+    const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+    if (!fragmentJsx) return;
+    fragmentJsx.children = [arg, devtoolsJsx];
+    node.argument = fragmentJsx;
+    added = true;
+  });
+  if (!added) {
+    throw new Error(
+      "Could not find a suitable location to add devtools. Expected a component with JSX return or {children}."
+    );
+  }
+  return { changed: true };
+}
+function generateProvidersContent(isTypeScript) {
+  const ext = isTypeScript ? "tsx" : "jsx";
+  const typeAnnotation = isTypeScript ? ": { children: React.ReactNode }" : "";
+  return `"use client";
+
+import React from "react";
+import "uilint-react/devtools";
+
+export function Providers({ children }${typeAnnotation}) {
+  return (
+    <>
+      {children}
+      <uilint-devtools />
+    </>
+  );
+}
+`;
+}
+function wrapChildrenWithProviders(program, providersImportPath) {
+  if (!program || program.type !== "Program") return { changed: false };
+  let hasProvidersImport = false;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ImportDeclaration") continue;
+    if (stmt.source?.value === providersImportPath) {
+      hasProvidersImport = true;
+      break;
+    }
+  }
+  if (!hasProvidersImport) {
+    const importRes = ensureNamedImport(program, providersImportPath, "Providers");
+    if (!importRes.changed) return { changed: false };
+  }
+  let wrapped = false;
+  walkAst(program, (node) => {
+    if (wrapped) return;
+    if (node.type !== "JSXElement" && node.type !== "JSXFragment") return;
+    const children = node.children ?? [];
+    const childrenIndex = children.findIndex(
+      (child) => child?.type === "JSXExpressionContainer" && child.expression?.type === "Identifier" && child.expression.name === "children"
+    );
+    if (childrenIndex === -1) return;
+    const providersMod = parseModule2(
+      "const __providers = (<Providers>{children}</Providers>);"
+    );
+    const providersJsx = providersMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+    if (!providersJsx) return;
+    children[childrenIndex] = providersJsx;
+    wrapped = true;
+  });
+  if (!wrapped) {
+    throw new Error(
+      "Could not find {children} in layout to wrap with Providers."
+    );
+  }
+  return { changed: true };
+}
+function findLayoutFile(projectPath, appRoot) {
+  const extensions = [".tsx", ".jsx", ".ts", ".js"];
+  for (const ext of extensions) {
+    const layoutPath = join5(projectPath, appRoot, `layout${ext}`);
+    if (existsSync5(layoutPath)) return layoutPath;
+  }
+  return null;
+}
+async function createProvidersAndModifyLayout(projectPath, appRoot) {
+  const layoutPath = findLayoutFile(projectPath, appRoot);
+  if (!layoutPath) {
+    throw new Error(`Could not find layout file in ${appRoot}`);
+  }
+  const isTypeScript = layoutPath.endsWith(".tsx") || layoutPath.endsWith(".ts");
+  const providersExt = isTypeScript ? ".tsx" : ".jsx";
+  const providersPath = join5(projectPath, appRoot, `providers${providersExt}`);
+  if (existsSync5(providersPath)) {
+    throw new Error(
+      `providers${providersExt} already exists. Please select it from the list instead.`
+    );
+  }
+  const providersContent = generateProvidersContent(isTypeScript);
+  writeFileSync2(providersPath, providersContent, "utf-8");
+  const layoutContent = readFileSync5(layoutPath, "utf-8");
+  let layoutMod;
+  try {
+    layoutMod = parseModule2(layoutContent);
+  } catch {
+    throw new Error(
+      `Unable to parse ${relative3(projectPath, layoutPath)} as JavaScript/TypeScript.`
+    );
+  }
+  const layoutProgram = layoutMod.$ast;
+  const wrapRes = wrapChildrenWithProviders(layoutProgram, "./providers");
+  if (wrapRes.changed) {
+    const updatedLayout = generateCode2(layoutMod).code;
+    writeFileSync2(layoutPath, updatedLayout, "utf-8");
+  }
+  return {
+    providersFile: relative3(projectPath, providersPath),
+    layoutFile: relative3(projectPath, layoutPath),
+    modified: true
+  };
+}
 async function installReactUILintOverlay(opts) {
+  if (opts.createProviders) {
+    const result = await createProvidersAndModifyLayout(
+      opts.projectPath,
+      opts.appRoot
+    );
+    return {
+      targetFile: result.providersFile,
+      modified: result.modified,
+      createdFile: result.providersFile,
+      layoutModified: result.layoutFile
+    };
+  }
+  if (opts.targetFile) {
+    const absTarget2 = opts.targetFile;
+    const relTarget = relative3(opts.projectPath, absTarget2);
+    if (!existsSync5(absTarget2)) {
+      throw new Error(`Target file not found: ${relTarget}`);
+    }
+    const original2 = readFileSync5(absTarget2, "utf-8");
+    let mod2;
+    try {
+      mod2 = parseModule2(original2);
+    } catch {
+      throw new Error(
+        `Unable to parse ${relTarget} as JavaScript/TypeScript. Please update it manually.`
+      );
+    }
+    const program2 = mod2.$ast;
+    const hasDevtoolsImport2 = !!findImportDeclaration(program2, "uilint-react/devtools");
+    const hasOldImport2 = !!findImportDeclaration(program2, "uilint-react");
+    const alreadyConfigured2 = (hasDevtoolsImport2 || hasOldImport2) && hasUILintDevtoolsJsx(program2);
+    if (alreadyConfigured2) {
+      return {
+        targetFile: relTarget,
+        modified: false,
+        alreadyConfigured: true
+      };
+    }
+    let changed2 = false;
+    const importRes2 = ensureSideEffectImport(program2, "uilint-react/devtools");
+    if (importRes2.changed) changed2 = true;
+    const addRes2 = addDevtoolsToClientComponent(program2);
+    if (addRes2.changed) changed2 = true;
+    const updated2 = changed2 ? generateCode2(mod2).code : original2;
+    const modified2 = updated2 !== original2;
+    if (modified2) {
+      writeFileSync2(absTarget2, updated2, "utf-8");
+    }
+    return {
+      targetFile: relTarget,
+      modified: modified2,
+      alreadyConfigured: false
+    };
+  }
   const candidates = getDefaultCandidates(opts.projectPath, opts.appRoot);
   if (!candidates.length) {
     throw new Error(
@@ -1916,7 +2088,7 @@ async function installReactUILintOverlay(opts) {
   } else {
     chosen = candidates[0];
   }
-  const absTarget = join6(opts.projectPath, chosen);
+  const absTarget = join5(opts.projectPath, chosen);
   const original = readFileSync5(absTarget, "utf-8");
   let mod;
   try {
@@ -1949,14 +2121,14 @@ async function installReactUILintOverlay(opts) {
 }
 
 // src/utils/next-config-inject.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
 import { parseModule as parseModule3, generateCode as generateCode3 } from "magicast";
 var CONFIG_EXTENSIONS2 = [".ts", ".mjs", ".js", ".cjs"];
 function findNextConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS2) {
-    const configPath = join7(projectPath, `next.config${ext}`);
-    if (existsSync7(configPath)) {
+    const configPath = join6(projectPath, `next.config${ext}`);
+    if (existsSync6(configPath)) {
       return configPath;
     }
   }
@@ -2099,14 +2271,14 @@ async function installJsxLocPlugin(opts) {
 }
 
 // src/utils/vite-config-inject.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 import { parseModule as parseModule4, generateCode as generateCode4 } from "magicast";
 var CONFIG_EXTENSIONS3 = [".ts", ".mjs", ".js", ".cjs"];
 function findViteConfigFile2(projectPath) {
   for (const ext of CONFIG_EXTENSIONS3) {
-    const configPath = join8(projectPath, `vite.config${ext}`);
-    if (existsSync8(configPath)) return configPath;
+    const configPath = join7(projectPath, `vite.config${ext}`);
+    if (existsSync7(configPath)) return configPath;
   }
   return null;
 }
@@ -2310,9 +2482,9 @@ async function installViteJsxLocPlugin(opts) {
 }
 
 // src/utils/next-routes.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 var DEV_SOURCE_ROUTE_TS = `/**
  * Dev-only API route for fetching source files
  *
@@ -2768,39 +2940,39 @@ export async function GET(request: NextRequest) {
 }
 `;
 async function writeRouteFile(absPath, relPath, content, opts) {
-  if (existsSync9(absPath) && !opts.force) return;
+  if (existsSync8(absPath) && !opts.force) return;
   await writeFile(absPath, content, "utf-8");
 }
 async function installNextUILintRoutes(opts) {
-  const baseRel = join9(opts.appRoot, "api", ".uilint");
-  const baseAbs = join9(opts.projectPath, baseRel);
-  await mkdir(join9(baseAbs, "source"), { recursive: true });
+  const baseRel = join8(opts.appRoot, "api", ".uilint");
+  const baseAbs = join8(opts.projectPath, baseRel);
+  await mkdir(join8(baseAbs, "source"), { recursive: true });
   await writeRouteFile(
-    join9(baseAbs, "source", "route.ts"),
-    join9(baseRel, "source", "route.ts"),
+    join8(baseAbs, "source", "route.ts"),
+    join8(baseRel, "source", "route.ts"),
     DEV_SOURCE_ROUTE_TS,
     opts
   );
-  await mkdir(join9(baseAbs, "screenshots"), { recursive: true });
+  await mkdir(join8(baseAbs, "screenshots"), { recursive: true });
   await writeRouteFile(
-    join9(baseAbs, "screenshots", "route.ts"),
-    join9(baseRel, "screenshots", "route.ts"),
+    join8(baseAbs, "screenshots", "route.ts"),
+    join8(baseRel, "screenshots", "route.ts"),
     SCREENSHOT_ROUTE_TS,
     opts
   );
 }
 
 // src/utils/prettier.ts
-import { existsSync as existsSync10 } from "fs";
-import { spawn as spawn2 } from "child_process";
-import { join as join10, dirname as dirname3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { spawn } from "child_process";
+import { join as join9, dirname as dirname3 } from "path";
 function getPrettierPath(projectPath) {
-  const localPath = join10(projectPath, "node_modules", ".bin", "prettier");
-  if (existsSync10(localPath)) return localPath;
+  const localPath = join9(projectPath, "node_modules", ".bin", "prettier");
+  if (existsSync9(localPath)) return localPath;
   let dir = projectPath;
   for (let i = 0; i < 10; i++) {
-    const binPath = join10(dir, "node_modules", ".bin", "prettier");
-    if (existsSync10(binPath)) return binPath;
+    const binPath = join9(dir, "node_modules", ".bin", "prettier");
+    if (existsSync9(binPath)) return binPath;
     const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
@@ -2827,7 +2999,7 @@ async function formatWithPrettier(filePath, projectPath) {
     const runner = getPmRunner(pm);
     return new Promise((resolve) => {
       const args = [...runner.args, "prettier", "--write", filePath];
-      const child = spawn2(runner.command, args, {
+      const child = spawn(runner.command, args, {
         cwd: projectPath,
         stdio: "pipe",
         shell: process.platform === "win32"
@@ -2849,7 +3021,7 @@ async function formatWithPrettier(filePath, projectPath) {
     });
   }
   return new Promise((resolve) => {
-    const child = spawn2(prettierPath, ["--write", filePath], {
+    const child = spawn(prettierPath, ["--write", filePath], {
       cwd: projectPath,
       stdio: "pipe",
       shell: process.platform === "win32"
@@ -2882,7 +3054,7 @@ async function formatFilesWithPrettier(filePaths, projectPath) {
     const runner = getPmRunner(pm);
     return new Promise((resolve) => {
       const args = [...runner.args, "prettier", "--write", ...filePaths];
-      const child = spawn2(runner.command, args, {
+      const child = spawn(runner.command, args, {
         cwd: projectPath,
         stdio: "pipe",
         shell: process.platform === "win32"
@@ -2900,7 +3072,7 @@ async function formatFilesWithPrettier(filePaths, projectPath) {
     });
   }
   return new Promise((resolve) => {
-    const child = spawn2(prettierPath, ["--write", ...filePaths], {
+    const child = spawn(prettierPath, ["--write", ...filePaths], {
       cwd: projectPath,
       stdio: "pipe",
       shell: process.platform === "win32"
@@ -2942,7 +3114,7 @@ async function executeAction(action, options) {
             wouldDo: `Create directory: ${action.path}`
           };
         }
-        if (!existsSync11(action.path)) {
+        if (!existsSync10(action.path)) {
           mkdirSync(action.path, { recursive: true });
         }
         return { action, success: true };
@@ -2956,7 +3128,7 @@ async function executeAction(action, options) {
           };
         }
         const dir = dirname4(action.path);
-        if (!existsSync11(dir)) {
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, action.content, "utf-8");
@@ -2974,7 +3146,7 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync11(action.path)) {
+        if (existsSync10(action.path)) {
           try {
             existing = JSON.parse(readFileSync8(action.path, "utf-8"));
           } catch {
@@ -2982,7 +3154,7 @@ async function executeAction(action, options) {
         }
         const merged = deepMerge(existing, action.merge);
         const dir = dirname4(action.path);
-        if (!existsSync11(dir)) {
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
@@ -2996,7 +3168,7 @@ async function executeAction(action, options) {
             wouldDo: `Delete file: ${action.path}`
           };
         }
-        if (existsSync11(action.path)) {
+        if (existsSync10(action.path)) {
           unlinkSync(action.path);
         }
         return { action, success: true };
@@ -3009,7 +3181,7 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync11(action.path)) {
+        if (existsSync10(action.path)) {
           const content = readFileSync8(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
@@ -3075,11 +3247,12 @@ async function executeInjectEslint(action, options) {
 }
 async function executeInjectReact(action, options) {
   const { dryRun = false } = options;
+  const dryRunDescription = action.createProviders ? `Create providers.tsx and inject <uilint-devtools /> in: ${action.projectPath}` : action.targetFile ? `Inject <uilint-devtools /> into: ${action.targetFile}` : `Inject <uilint-devtools /> into React app: ${action.projectPath}`;
   if (dryRun) {
     return {
       action,
       success: true,
-      wouldDo: `Inject <uilint-devtools /> into React app: ${action.projectPath}`
+      wouldDo: dryRunDescription
     };
   }
   const result = await installReactUILintOverlay({
@@ -3087,7 +3260,10 @@ async function executeInjectReact(action, options) {
     appRoot: action.appRoot,
     mode: action.mode,
     force: false,
-    // Auto-select first choice for execute phase
+    // Pass through targetFile and createProviders from the action
+    targetFile: action.targetFile,
+    createProviders: action.createProviders,
+    // Auto-select first choice for execute phase (fallback if no targetFile)
     confirmFileChoice: async (choices) => choices[0]
   });
   const success = result.modified || result.alreadyConfigured === true;
@@ -3371,11 +3547,9 @@ async function execute(plan, options = {}) {
 
 // src/commands/install-ui.tsx
 import { ruleRegistry as ruleRegistry3 } from "uilint-eslint";
-import { existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
 
 // src/commands/install/installers/genstyleguide.ts
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 var genstyleguideInstaller = {
   id: "genstyleguide",
   name: "/genstyleguide command",
@@ -3385,7 +3559,7 @@ var genstyleguideInstaller = {
     return true;
   },
   getTargets(project) {
-    const commandPath = join11(project.cursorDir.path, "commands", "genstyleguide.md");
+    const commandPath = join10(project.cursorDir.path, "commands", "genstyleguide.md");
     const isInstalled = project.commands.genstyleguide;
     return [
       {
@@ -3398,7 +3572,7 @@ var genstyleguideInstaller = {
   },
   plan(targets, config, project) {
     const actions = [];
-    const commandsDir = join11(project.cursorDir.path, "commands");
+    const commandsDir = join10(project.cursorDir.path, "commands");
     if (!project.cursorDir.exists) {
       actions.push({
         type: "create_directory",
@@ -3411,7 +3585,7 @@ var genstyleguideInstaller = {
     });
     actions.push({
       type: "create_file",
-      path: join11(commandsDir, "genstyleguide.md"),
+      path: join10(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
     return {
@@ -3441,8 +3615,8 @@ var genstyleguideInstaller = {
 };
 
 // src/commands/install/installers/skill.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
 var skillInstaller = {
   id: "skill",
   name: "UI Consistency Agent skill",
@@ -3452,9 +3626,9 @@ var skillInstaller = {
     return true;
   },
   getTargets(project) {
-    const skillsDir = join12(project.cursorDir.path, "skills", "ui-consistency-enforcer");
-    const skillMdPath = join12(skillsDir, "SKILL.md");
-    const isInstalled = existsSync12(skillMdPath);
+    const skillsDir = join11(project.cursorDir.path, "skills", "ui-consistency-enforcer");
+    const skillMdPath = join11(skillsDir, "SKILL.md");
+    const isInstalled = existsSync11(skillMdPath);
     return [
       {
         id: "ui-consistency-skill",
@@ -3473,21 +3647,21 @@ var skillInstaller = {
         path: project.cursorDir.path
       });
     }
-    const skillsDir = join12(project.cursorDir.path, "skills");
+    const skillsDir = join11(project.cursorDir.path, "skills");
     actions.push({
       type: "create_directory",
       path: skillsDir
     });
     try {
       const skill = loadSkill("ui-consistency-enforcer");
-      const skillDir = join12(skillsDir, skill.name);
+      const skillDir = join11(skillsDir, skill.name);
       actions.push({
         type: "create_directory",
         path: skillDir
       });
       for (const file of skill.files) {
-        const filePath = join12(skillDir, file.relativePath);
-        const fileDir = join12(
+        const filePath = join11(skillDir, file.relativePath);
+        const fileDir = join11(
           skillDir,
           file.relativePath.split("/").slice(0, -1).join("/")
         );
@@ -3544,8 +3718,21 @@ var skillInstaller = {
 };
 
 // src/commands/install/installers/eslint.ts
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 import { ruleRegistry as ruleRegistry2, getRulesByCategory as getRulesByCategory2 } from "uilint-eslint";
+function getUpgradeInfo(configuredRuleIds) {
+  const configuredSet = new Set(configuredRuleIds);
+  const allRuleIds = ruleRegistry2.map((r) => r.id);
+  const missingRules = allRuleIds.filter((id) => !configuredSet.has(id));
+  if (missingRules.length === 0) {
+    return void 0;
+  }
+  const summary = missingRules.length === 1 ? "1 new rule available" : `${missingRules.length} new rules available`;
+  return {
+    missingRules,
+    summary
+  };
+}
 function toInstallSpecifier(pkgName) {
   return pkgName;
 }
@@ -3566,13 +3753,22 @@ var eslintInstaller = {
     return project.packages.some((pkg) => pkg.eslintConfigPath !== null);
   },
   getTargets(project) {
-    return project.packages.filter((pkg) => pkg.eslintConfigPath !== null).map((pkg) => ({
-      id: `eslint-${pkg.name}`,
-      label: pkg.name,
-      path: pkg.path,
-      hint: pkg.eslintConfigFilename || "ESLint config detected",
-      isInstalled: pkg.hasUilintRules
-    }));
+    return project.packages.filter((pkg) => pkg.eslintConfigPath !== null).map((pkg) => {
+      const upgradeInfo = pkg.hasUilintRules ? getUpgradeInfo(pkg.configuredRuleIds) : void 0;
+      let hint = pkg.eslintConfigFilename || "ESLint config detected";
+      if (upgradeInfo?.summary) {
+        hint = `${hint} \xB7 ${upgradeInfo.summary}`;
+      }
+      return {
+        id: `eslint-${pkg.name}`,
+        label: pkg.name,
+        path: pkg.path,
+        hint,
+        isInstalled: pkg.hasUilintRules,
+        canUpgrade: upgradeInfo !== void 0,
+        upgradeInfo
+      };
+    });
   },
   async configure(targets, project) {
     const staticRules = getRulesByCategory2("static");
@@ -3698,14 +3894,14 @@ var eslintInstaller = {
     for (const target of targets) {
       const pkgInfo = project.packages.find((p) => p.path === target.path);
       if (!pkgInfo || !pkgInfo.eslintConfigPath) continue;
-      const rulesDir = join13(target.path, ".uilint", "rules");
+      const rulesDir = join12(target.path, ".uilint", "rules");
       actions.push({
         type: "create_directory",
         path: rulesDir
       });
       dependencies.push({
         packagePath: target.path,
-        packageManager: project.packageManager,
+        packageManager: detectPackageManager(target.path),
         packages: [toInstallSpecifier("uilint-eslint"), "typescript-eslint"]
       });
       actions.push({
@@ -3716,7 +3912,7 @@ var eslintInstaller = {
         hasExistingRules: pkgInfo.hasUilintRules
       });
     }
-    const gitignorePath = join13(project.workspaceRoot, ".gitignore");
+    const gitignorePath = join12(project.workspaceRoot, ".gitignore");
     actions.push({
       type: "append_to_file",
       path: gitignorePath,
@@ -3750,6 +3946,143 @@ var eslintInstaller = {
   }
 };
 
+// src/utils/client-boundary-tracer.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { join as join13, dirname as dirname5, relative as relative4 } from "path";
+import { parseModule as parseModule5 } from "magicast";
+function hasUseClientDirective(filePath) {
+  try {
+    const content = readFileSync9(filePath, "utf-8");
+    const mod = parseModule5(content);
+    const program = mod.$ast;
+    if (!program || program.type !== "Program") return false;
+    const firstStmt = program.body?.[0];
+    return firstStmt?.type === "ExpressionStatement" && firstStmt.expression?.type === "StringLiteral" && (firstStmt.expression.value === "use client" || firstStmt.expression.value === "use client");
+  } catch {
+    return false;
+  }
+}
+function extractImports(program) {
+  const imports = [];
+  if (!program || program.type !== "Program") return imports;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ImportDeclaration") continue;
+    const source = stmt.source?.value;
+    if (typeof source !== "string") continue;
+    if (!source.startsWith(".") && !source.startsWith("@/") && !source.startsWith("~/")) {
+      continue;
+    }
+    const specifiers = [];
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type === "ImportDefaultSpecifier") {
+        specifiers.push("default");
+      } else if (spec.type === "ImportSpecifier") {
+        const name = spec.imported?.name ?? spec.imported?.value;
+        if (name) specifiers.push(name);
+      } else if (spec.type === "ImportNamespaceSpecifier") {
+        specifiers.push("*");
+      }
+    }
+    imports.push({ source, specifiers });
+  }
+  return imports;
+}
+function resolveImportPath(importSource, fromFile, projectPath) {
+  const fromDir = dirname5(fromFile);
+  let basePath;
+  if (importSource.startsWith("@/")) {
+    const withoutAlias = importSource.slice(2);
+    const srcPath = join13(projectPath, "src", withoutAlias);
+    const rootPath = join13(projectPath, withoutAlias);
+    basePath = existsSync12(dirname5(srcPath)) ? srcPath : rootPath;
+  } else if (importSource.startsWith("~/")) {
+    basePath = join13(projectPath, importSource.slice(2));
+  } else if (importSource.startsWith(".")) {
+    basePath = join13(fromDir, importSource);
+  } else {
+    return null;
+  }
+  const extensions = [".tsx", ".ts", ".jsx", ".js"];
+  for (const ext of extensions) {
+    const fullPath = basePath + ext;
+    if (existsSync12(fullPath)) return fullPath;
+  }
+  for (const ext of extensions) {
+    const indexPath = join13(basePath, `index${ext}`);
+    if (existsSync12(indexPath)) return indexPath;
+  }
+  if (existsSync12(basePath)) return basePath;
+  return null;
+}
+function findLayoutFile2(projectPath, appRoot) {
+  const extensions = [".tsx", ".jsx", ".ts", ".js"];
+  for (const ext of extensions) {
+    const layoutPath = join13(projectPath, appRoot, `layout${ext}`);
+    if (existsSync12(layoutPath)) return layoutPath;
+  }
+  return null;
+}
+function traceClientBoundaries(projectPath, appRoot) {
+  const layoutFile = findLayoutFile2(projectPath, appRoot);
+  if (!layoutFile) {
+    return null;
+  }
+  const layoutIsClient = hasUseClientDirective(layoutFile);
+  const layoutRelative = relative4(projectPath, layoutFile);
+  if (layoutIsClient) {
+    return {
+      layoutIsClient: true,
+      clientBoundaries: [],
+      layoutFile,
+      layoutRelative
+    };
+  }
+  let program;
+  try {
+    const content = readFileSync9(layoutFile, "utf-8");
+    const mod = parseModule5(content);
+    program = mod.$ast;
+  } catch {
+    return {
+      layoutIsClient: false,
+      clientBoundaries: [],
+      layoutFile,
+      layoutRelative
+    };
+  }
+  const imports = extractImports(program);
+  const clientBoundaries = [];
+  for (const imp of imports) {
+    const resolvedPath = resolveImportPath(imp.source, layoutFile, projectPath);
+    if (!resolvedPath) continue;
+    if (hasUseClientDirective(resolvedPath)) {
+      clientBoundaries.push({
+        filePath: resolvedPath,
+        relativePath: relative4(projectPath, resolvedPath),
+        componentNames: imp.specifiers,
+        importSource: imp.source
+      });
+    }
+  }
+  return {
+    layoutIsClient: false,
+    clientBoundaries,
+    layoutFile,
+    layoutRelative
+  };
+}
+function providersFileExists(projectPath, appRoot) {
+  const extensions = [".tsx", ".jsx", ".ts", ".js"];
+  const names = ["providers", "Providers"];
+  for (const name of names) {
+    for (const ext of extensions) {
+      const providersPath = join13(projectPath, appRoot, `${name}${ext}`);
+      if (existsSync12(providersPath)) return providersPath;
+    }
+  }
+  return null;
+}
+
 // src/commands/install/installers/next-overlay.ts
 var nextOverlayInstaller = {
   id: "next",
@@ -3760,21 +4093,95 @@ var nextOverlayInstaller = {
     return project.nextApps.length > 0;
   },
   getTargets(project) {
-    return project.nextApps.map((app) => ({
-      id: `next-${app.projectPath}`,
-      label: app.projectPath.split("/").pop() || app.projectPath,
-      path: app.projectPath,
-      hint: "App Router",
-      isInstalled: false
-      // TODO: Detect if already installed
-    }));
+    const targets = [];
+    for (const app of project.nextApps) {
+      const traceResult = traceClientBoundaries(
+        app.projectPath,
+        app.detection.appRoot
+      );
+      if (!traceResult) {
+        targets.push({
+          id: `next-${app.projectPath}`,
+          label: app.projectPath.split("/").pop() || app.projectPath,
+          path: app.projectPath,
+          hint: "App Router (no layout found)",
+          isInstalled: false
+        });
+        continue;
+      }
+      if (traceResult.layoutIsClient) {
+        targets.push({
+          id: `next-${app.projectPath}`,
+          label: app.projectPath.split("/").pop() || app.projectPath,
+          path: app.projectPath,
+          hint: "App Router",
+          isInstalled: false,
+          targetFile: traceResult.layoutFile
+        });
+        continue;
+      }
+      const existingProviders = providersFileExists(
+        app.projectPath,
+        app.detection.appRoot
+      );
+      if (!existingProviders) {
+        targets.push({
+          id: `next-${app.projectPath}-create-providers`,
+          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
+          path: app.projectPath,
+          hint: "Create providers.tsx (Recommended)",
+          isInstalled: false,
+          createProviders: true
+        });
+      }
+      for (const boundary of traceResult.clientBoundaries) {
+        const componentNames = boundary.componentNames.length > 0 ? boundary.componentNames.join(", ") : "default";
+        targets.push({
+          id: `next-${app.projectPath}-${boundary.relativePath}`,
+          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
+          path: app.projectPath,
+          hint: `${boundary.relativePath} (${componentNames})`,
+          isInstalled: false,
+          targetFile: boundary.filePath
+        });
+      }
+      if (existingProviders) {
+        const relativePath = existingProviders.replace(app.projectPath + "/", "").replace(app.projectPath, "");
+        const alreadyListed = traceResult.clientBoundaries.some(
+          (b) => b.filePath === existingProviders
+        );
+        if (!alreadyListed) {
+          targets.push({
+            id: `next-${app.projectPath}-existing-providers`,
+            label: `${app.projectPath.split("/").pop() || app.projectPath}`,
+            path: app.projectPath,
+            hint: `${relativePath} (existing)`,
+            isInstalled: false,
+            targetFile: existingProviders
+          });
+        }
+      }
+      if (targets.filter((t) => t.path === app.projectPath).length === 0) {
+        targets.push({
+          id: `next-${app.projectPath}-create-providers`,
+          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
+          path: app.projectPath,
+          hint: "Create providers.tsx",
+          isInstalled: false,
+          createProviders: true
+        });
+      }
+    }
+    return targets;
   },
   plan(targets, config, project) {
     const actions = [];
     const dependencies = [];
     if (targets.length === 0) return { actions, dependencies };
     const target = targets[0];
-    const appInfo = project.nextApps.find((app) => app.projectPath === target.path);
+    const appInfo = project.nextApps.find(
+      (app) => app.projectPath === target.path
+    );
     if (!appInfo) return { actions, dependencies };
     const { projectPath, detection } = appInfo;
     actions.push({
@@ -3791,7 +4198,9 @@ var nextOverlayInstaller = {
       type: "inject_react",
       projectPath,
       appRoot: detection.appRoot,
-      mode: "next"
+      mode: "next",
+      targetFile: target.targetFile,
+      createProviders: target.createProviders
     });
     actions.push({
       type: "inject_next_config",
@@ -3816,10 +4225,11 @@ var nextOverlayInstaller = {
       message: "Installing dependencies",
       detail: "\u2192 uilint-react, uilint-core, jsx-loc-plugin"
     };
+    const injectDetail = target.createProviders ? "\u2192 Creating providers.tsx" : target.targetFile ? `\u2192 ${target.hint || "client component"}` : "\u2192 <uilint-devtools /> in root layout";
     yield {
       type: "progress",
       message: "Injecting devtools component",
-      detail: "\u2192 <uilint-devtools /> in root layout"
+      detail: injectDetail
     };
     yield {
       type: "progress",
@@ -3973,56 +4383,6 @@ function selectionsToUserChoices(selections, project, eslintRules) {
 function isInteractiveTerminal() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
-function getRecommendedCommand(pm) {
-  switch (pm) {
-    case "pnpm":
-      return "pnpm dlx uilint install";
-    case "yarn":
-      return "yarn dlx uilint install";
-    case "bun":
-      return "bunx uilint install";
-    case "npm":
-    default:
-      return "npx uilint install";
-  }
-}
-async function warnOnPackageManagerMismatch(projectPromise) {
-  const executionPm = detectExecutionPackageManager();
-  if (!executionPm) return;
-  const project = await projectPromise;
-  const packageManagers = /* @__PURE__ */ new Set();
-  const hasRootPackageJson = existsSync13(join14(project.projectPath, "package.json"));
-  if (hasRootPackageJson) {
-    packageManagers.add(project.packageManager);
-  } else {
-    for (const pkg of project.packages) {
-      const pm = detectPackageManager(pkg.path);
-      packageManagers.add(pm);
-    }
-  }
-  const specificPackageManagers = Array.from(packageManagers).filter(
-    (pm) => pm !== "npm" || hasRootPackageJson
-  );
-  if (specificPackageManagers.length === 0) return;
-  if (specificPackageManagers.includes(executionPm)) return;
-  const primaryPm = specificPackageManagers[0];
-  const recommendedCmd = getRecommendedCommand(primaryPm);
-  const pmList = specificPackageManagers.length === 1 ? specificPackageManagers[0] : specificPackageManagers.join(", ");
-  printBox(
-    "Package manager mismatch detected",
-    [
-      `This project uses ${pmList}, but you ran this command with ${executionPm}.`,
-      "",
-      `Running with ${executionPm} may create unwanted lockfiles.`,
-      "",
-      "Recommended:",
-      `  ${recommendedCmd}`,
-      "",
-      "Continuing anyway..."
-    ],
-    "warning"
-  );
-}
 async function installUI(options = {}, executeOptions = {}) {
   const projectPath = process.cwd();
   if (!isInteractiveTerminal()) {
@@ -4031,7 +4391,6 @@ async function installUI(options = {}, executeOptions = {}) {
     process.exit(1);
   }
   const projectPromise = analyze(projectPath);
-  await warnOnPackageManagerMismatch(projectPromise);
   const { waitUntilExit } = render(
     /* @__PURE__ */ jsx6(
       InstallApp,
@@ -4044,7 +4403,7 @@ async function installUI(options = {}, executeOptions = {}) {
             console.log("\nNo items selected for installation");
             process.exit(0);
           }
-          const { createPlan } = await import("./plan-PX7FFJ25.js");
+          const { createPlan } = await import("./plan-VPDTICSY.js");
           const plan = createPlan(project, choices, { force: options.force });
           const result = await execute(plan, {
             ...executeOptions,
@@ -4069,4 +4428,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-ITXPOUVQ.js.map
+//# sourceMappingURL=install-ui-73AINMZ5.js.map