uilint 0.2.12 → 0.2.14

package/dist/{install-ui-LK7HD2IM.js → install-ui-H2KOQ6SP.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,49 +1691,49 @@ 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,
   unlinkSync,
   chmodSync
 } from "fs";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname3 } 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 } 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";
@@ -1916,7 +1865,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 +1898,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 +2048,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 +2259,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,40 +2717,40 @@ 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 dirname2 } 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 parent = dirname3(dir);
+    const binPath = join9(dir, "node_modules", ".bin", "prettier");
+    if (existsSync9(binPath)) return binPath;
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -2827,7 +2776,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 +2798,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 +2831,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 +2849,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 +2891,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 };
@@ -2955,8 +2904,8 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname4(action.path);
-        if (!existsSync11(dir)) {
+        const dir = dirname3(action.path);
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, action.content, "utf-8");
@@ -2974,15 +2923,15 @@ 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 {
           }
         }
         const merged = deepMerge(existing, action.merge);
-        const dir = dirname4(action.path);
-        if (!existsSync11(dir)) {
+        const dir = dirname3(action.path);
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
@@ -2996,7 +2945,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 +2958,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 };
@@ -3373,7 +3322,7 @@ async function execute(plan, options = {}) {
 import { ruleRegistry as ruleRegistry3 } from "uilint-eslint";
 
 // 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",
@@ -3383,7 +3332,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 [
       {
@@ -3396,7 +3345,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",
@@ -3409,7 +3358,7 @@ var genstyleguideInstaller = {
     });
     actions.push({
       type: "create_file",
-      path: join11(commandsDir, "genstyleguide.md"),
+      path: join10(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
     return {
@@ -3439,8 +3388,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",
@@ -3450,9 +3399,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",
@@ -3471,21 +3420,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("/")
         );
@@ -3542,8 +3491,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;
 }
@@ -3564,13 +3526,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");
@@ -3696,14 +3667,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({
@@ -3714,7 +3685,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,
@@ -3971,41 +3942,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 projectPm = project.packageManager;
-  if (executionPm === projectPm) return;
-  const recommendedCmd = getRecommendedCommand(projectPm);
-  printBox(
-    "Package manager mismatch detected",
-    [
-      `This project uses ${projectPm}, but you ran this command with ${executionPm}.`,
-      "",
-      `This may create unwanted lockfiles (e.g., package-lock.json).`,
-      "",
-      "Recommended:",
-      `  ${recommendedCmd}`,
-      "",
-      "Continuing anyway..."
-    ],
-    "warning"
-  );
-}
 async function installUI(options = {}, executeOptions = {}) {
   const projectPath = process.cwd();
   if (!isInteractiveTerminal()) {
@@ -4014,7 +3950,6 @@ async function installUI(options = {}, executeOptions = {}) {
     process.exit(1);
   }
   const projectPromise = analyze(projectPath);
-  await warnOnPackageManagerMismatch(projectPromise);
   const { waitUntilExit } = render(
     /* @__PURE__ */ jsx6(
       InstallApp,
@@ -4027,7 +3962,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-G43256ML.js");
           const plan = createPlan(project, choices, { force: options.force });
           const result = await execute(plan, {
             ...executeOptions,
@@ -4052,4 +3987,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-LK7HD2IM.js.map
+//# sourceMappingURL=install-ui-H2KOQ6SP.js.map