uilint 0.2.22 → 0.2.26

package/dist/{install-ui-HTVB5HDB.js → install-ui-CCZ3XJDE.js}

@@ -1,20 +1,31 @@
 #!/usr/bin/env node
 import {
   confirm,
+  detectCoverageSetup,
   detectNextAppRouter,
+  findEslintConfigFile,
   findNextAppRouterProjects,
+  getEslintConfigFilename,
+  getUilintEslintConfigInfoFromSource,
+  injectCoverageConfig,
+  installEslintPlugin,
   log,
   multiselect,
   note,
   pc,
-  select
-} from "./chunk-FRNXXIEM.js";
+  select,
+  uninstallEslintPlugin
+} from "./chunk-VNANPKR2.js";
 import {
   GENSTYLEGUIDE_COMMAND_MD,
+  loadSkill,
+  toInstallSpecifier
+} from "./chunk-TWUDB36F.js";
+import {
   detectPackageManager,
   installDependencies,
-  loadSkill
-} from "./chunk-PBEKMDUH.js";
+  runTestsWithCoverage
+} from "./chunk-P4I4RKBY.js";
 
 // src/commands/install-ui.tsx
 import { render } from "ink";
@@ -841,7 +852,7 @@ var nextOverlayInstaller = {
       label: app.projectPath.split("/").pop() || app.projectPath,
       path: app.projectPath,
       hint: "App Router",
-      isInstalled: false
+      isInstalled: app.hasUilintOverlay
     }));
   },
   plan(targets, config, project) {
@@ -865,7 +876,19 @@ var nextOverlayInstaller = {
     dependencies.push({
       packagePath: projectPath,
       packageManager: project.packageManager,
-      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+      packages: [
+        toInstallSpecifier("uilint-react", {
+          preferWorkspaceProtocol: project.packageManager === "pnpm",
+          workspaceRoot: project.workspaceRoot,
+          targetProjectPath: projectPath
+        }),
+        toInstallSpecifier("uilint-core", {
+          preferWorkspaceProtocol: project.packageManager === "pnpm",
+          workspaceRoot: project.workspaceRoot,
+          targetProjectPath: projectPath
+        }),
+        "jsx-loc-plugin"
+      ]
     });
     actions.push({
       type: "inject_react",
@@ -1309,9 +1332,9 @@ function InstallApp({
 }
 
 // src/commands/install/analyze.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
-import { findWorkspaceRoot as findWorkspaceRoot2 } from "uilint-core/node";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+import { findWorkspaceRoot } from "uilint-core/node";
 
 // src/utils/vite-detect.ts
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
@@ -1554,644 +1577,63 @@ function findPackages(rootDir, options) {
   });
 }
 
-// src/utils/eslint-config-inject.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync } from "fs";
-import { join as join4, relative as relative3, dirname as dirname2 } from "path";
-import { parseExpression, parseModule as parseModule2, 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)) {
-      return configPath;
-    }
-  }
-  return null;
-}
-function getEslintConfigFilename(configPath) {
-  const parts = configPath.split("/");
-  return parts[parts.length - 1] || "eslint.config.mjs";
-}
-function isIdentifier(node, name) {
-  return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
-}
-function isStringLiteral(node) {
-  return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
-}
-function getObjectPropertyValue(obj, keyName) {
-  if (!obj || obj.type !== "ObjectExpression") return null;
-  for (const prop of obj.properties ?? []) {
-    if (!prop) continue;
-    if (prop.type === "ObjectProperty" || prop.type === "Property") {
-      const key = prop.key;
-      const keyMatch = key?.type === "Identifier" && key.name === keyName || isStringLiteral(key) && key.value === keyName;
-      if (keyMatch) return prop.value;
-    }
-  }
-  return null;
-}
-function hasSpreadProperties(obj) {
-  if (!obj || obj.type !== "ObjectExpression") return false;
-  return (obj.properties ?? []).some(
-    (p) => p && (p.type === "SpreadElement" || p.type === "SpreadProperty")
-  );
-}
-var IGNORED_AST_KEYS = /* @__PURE__ */ new Set([
-  "loc",
-  "start",
-  "end",
-  "extra",
-  "leadingComments",
-  "trailingComments",
-  "innerComments"
-]);
-function normalizeAstForCompare(node) {
-  if (node === null) return null;
-  if (node === void 0) return void 0;
-  if (typeof node !== "object") return node;
-  if (Array.isArray(node)) return node.map(normalizeAstForCompare);
-  const out = {};
-  const keys = Object.keys(node).filter((k) => !IGNORED_AST_KEYS.has(k)).sort();
-  for (const k of keys) {
-    if (k.startsWith("$")) continue;
-    out[k] = normalizeAstForCompare(node[k]);
-  }
-  return out;
-}
-function astEquivalent(a, b) {
-  try {
-    return JSON.stringify(normalizeAstForCompare(a)) === JSON.stringify(normalizeAstForCompare(b));
-  } catch {
-    return false;
-  }
-}
-function collectUilintRuleIdsFromRulesObject(rulesObj) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!rulesObj || rulesObj.type !== "ObjectExpression") return ids;
-  for (const prop of rulesObj.properties ?? []) {
-    if (!prop) continue;
-    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
-    const key = prop.key;
-    if (!isStringLiteral(key)) continue;
-    const val = key.value;
-    if (typeof val !== "string") continue;
-    if (val.startsWith("uilint/")) {
-      ids.add(val.slice("uilint/".length));
-    }
-  }
-  return ids;
-}
-function findExportedConfigArrayExpression(mod) {
-  function unwrapExpression2(expr) {
-    let e = expr;
-    while (e) {
-      if (e.type === "TSAsExpression" || e.type === "TSNonNullExpression") {
-        e = e.expression;
-        continue;
-      }
-      if (e.type === "TSSatisfiesExpression") {
-        e = e.expression;
-        continue;
-      }
-      if (e.type === "ParenthesizedExpression") {
-        e = e.expression;
-        continue;
-      }
-      break;
-    }
-    return e;
-  }
-  function resolveTopLevelIdentifierToArrayExpr(program2, name) {
-    if (!program2 || program2.type !== "Program") return null;
-    for (const stmt of program2.body ?? []) {
-      if (stmt?.type !== "VariableDeclaration") continue;
-      for (const decl of stmt.declarations ?? []) {
-        const id = decl?.id;
-        if (!isIdentifier(id, name)) continue;
-        const init = unwrapExpression2(decl?.init);
-        if (!init) return null;
-        if (init.type === "ArrayExpression") return init;
-        if (init.type === "CallExpression" && isIdentifier(init.callee, "defineConfig") && unwrapExpression2(init.arguments?.[0])?.type === "ArrayExpression") {
-          return unwrapExpression2(init.arguments?.[0]);
-        }
-        return null;
-      }
-    }
-    return null;
-  }
-  const program = mod?.$ast;
-  if (program && program.type === "Program") {
-    for (const stmt of program.body ?? []) {
-      if (!stmt || stmt.type !== "ExportDefaultDeclaration") continue;
-      const decl = unwrapExpression2(stmt.declaration);
-      if (!decl) break;
-      if (decl.type === "ArrayExpression") {
-        return { kind: "esm", arrayExpr: decl, program };
-      }
-      if (decl.type === "CallExpression" && isIdentifier(decl.callee, "defineConfig") && unwrapExpression2(decl.arguments?.[0])?.type === "ArrayExpression") {
-        return {
-          kind: "esm",
-          arrayExpr: unwrapExpression2(decl.arguments?.[0]),
-          program
-        };
-      }
-      if (decl.type === "Identifier" && typeof decl.name === "string") {
-        const resolved = resolveTopLevelIdentifierToArrayExpr(
-          program,
-          decl.name
-        );
-        if (resolved) return { kind: "esm", arrayExpr: resolved, program };
-      }
-      break;
-    }
-  }
-  if (!program || program.type !== "Program") return null;
-  for (const stmt of program.body ?? []) {
-    if (!stmt || stmt.type !== "ExpressionStatement") continue;
-    const expr = stmt.expression;
-    if (!expr || expr.type !== "AssignmentExpression") continue;
-    const left = expr.left;
-    const right = expr.right;
-    const isModuleExports = left?.type === "MemberExpression" && isIdentifier(left.object, "module") && isIdentifier(left.property, "exports");
-    if (!isModuleExports) continue;
-    if (right?.type === "ArrayExpression") {
-      return { kind: "cjs", arrayExpr: right, program };
-    }
-    if (right?.type === "CallExpression" && isIdentifier(right.callee, "defineConfig") && right.arguments?.[0]?.type === "ArrayExpression") {
-      return { kind: "cjs", arrayExpr: right.arguments[0], program };
-    }
-    if (right?.type === "Identifier" && typeof right.name === "string") {
-      const resolved = resolveTopLevelIdentifierToArrayExpr(
-        program,
-        right.name
-      );
-      if (resolved) return { kind: "cjs", arrayExpr: resolved, program };
-    }
-  }
-  return null;
-}
-function collectConfiguredUilintRuleIdsFromConfigArray(arrayExpr) {
-  const ids = /* @__PURE__ */ new Set();
-  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return ids;
-  for (const el of arrayExpr.elements ?? []) {
-    if (!el || el.type !== "ObjectExpression") continue;
-    const rules = getObjectPropertyValue(el, "rules");
-    for (const id of collectUilintRuleIdsFromRulesObject(rules)) ids.add(id);
-  }
-  return ids;
-}
-function findExistingUilintRulesObject(arrayExpr) {
-  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") {
-    return { configObj: null, rulesObj: null, safeToMutate: false };
-  }
-  for (const el of arrayExpr.elements ?? []) {
-    if (!el || el.type !== "ObjectExpression") continue;
-    const plugins = getObjectPropertyValue(el, "plugins");
-    const rules = getObjectPropertyValue(el, "rules");
-    const hasUilintPlugin = plugins?.type === "ObjectExpression" && getObjectPropertyValue(plugins, "uilint") !== null;
-    const uilintIds = collectUilintRuleIdsFromRulesObject(rules);
-    const hasUilintRules = uilintIds.size > 0;
-    if (!hasUilintPlugin && !hasUilintRules) continue;
-    const safe = rules?.type === "ObjectExpression" && !hasSpreadProperties(rules);
-    return { configObj: el, rulesObj: rules, safeToMutate: safe };
-  }
-  return { configObj: null, rulesObj: null, safeToMutate: false };
-}
-function collectTopLevelBindings(program) {
-  const names = /* @__PURE__ */ new Set();
-  if (!program || program.type !== "Program") return names;
-  for (const stmt of program.body ?? []) {
-    if (stmt?.type === "VariableDeclaration") {
-      for (const decl of stmt.declarations ?? []) {
-        const id = decl?.id;
-        if (id?.type === "Identifier" && typeof id.name === "string") {
-          names.add(id.name);
-        }
-      }
-    } else if (stmt?.type === "FunctionDeclaration") {
-      if (stmt.id?.type === "Identifier" && typeof stmt.id.name === "string") {
-        names.add(stmt.id.name);
-      }
-    }
-  }
-  return names;
-}
-function chooseUniqueIdentifier(base, used) {
-  if (!used.has(base)) return base;
-  let i = 2;
-  while (used.has(`${base}${i}`)) i++;
-  return `${base}${i}`;
-}
-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 relativeRulesPath = relative3(configDir, rulesDir).replace(/\\/g, "/");
-  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
-  const used = collectTopLevelBindings(mod.$ast);
-  for (const rule of selectedRules) {
-    const importName = chooseUniqueIdentifier(
-      `${rule.id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase())}Rule`,
-      used
-    );
-    importNames.set(rule.id, importName);
-    used.add(importName);
-    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
-    mod.imports.$add({
-      imported: "default",
-      local: importName,
-      from: rulePath
-    });
-    changed = true;
-  }
-  return { importNames, changed };
-}
-function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
-  const importNames = /* @__PURE__ */ new Map();
-  let changed = false;
-  if (!program || program.type !== "Program") {
-    return { importNames, changed };
-  }
-  const configDir = dirname2(configPath);
-  const rulesDir = join4(rulesRoot, ".uilint", "rules");
-  const relativeRulesPath = relative3(configDir, rulesDir).replace(/\\/g, "/");
-  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
-  const used = collectTopLevelBindings(program);
-  for (const rule of selectedRules) {
-    const importName = chooseUniqueIdentifier(
-      `${rule.id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase())}Rule`,
-      used
-    );
-    importNames.set(rule.id, importName);
-    used.add(importName);
-    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
-    const stmtMod = parseModule2(
-      `const ${importName} = require("${rulePath}");`
-    );
-    const stmt = stmtMod.$ast.body?.[0];
-    if (stmt) {
-      let insertAt = 0;
-      const first = program.body?.[0];
-      if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
-        insertAt = 1;
-      }
-      program.body.splice(insertAt, 0, stmt);
-      changed = true;
-    }
-  }
-  return { importNames, changed };
-}
-function appendUilintConfigBlockToArray(arrayExpr, selectedRules, ruleImportNames) {
-  const pluginRulesCode = Array.from(ruleImportNames.entries()).map(([ruleId, importName]) => `      "${ruleId}": ${importName},`).join("\n");
-  const rulesPropsCode = selectedRules.map((r) => {
-    const ruleKey = `uilint/${r.id}`;
-    const valueCode = r.defaultOptions && r.defaultOptions.length > 0 ? `["${r.defaultSeverity}", ...${JSON.stringify(
-      r.defaultOptions,
-      null,
-      2
-    )}]` : `"${r.defaultSeverity}"`;
-    return `      "${ruleKey}": ${valueCode},`;
-  }).join("\n");
-  const blockCode = `{
-    files: [
-      "src/**/*.{js,jsx,ts,tsx}",
-      "app/**/*.{js,jsx,ts,tsx}",
-      "pages/**/*.{js,jsx,ts,tsx}",
-    ],
-    plugins: {
-      uilint: {
-        rules: {
-${pluginRulesCode}
-        },
-      },
-    },
-    rules: {
-${rulesPropsCode}
-    },
-  }`;
-  const objExpr = parseExpression(blockCode).$ast;
-  arrayExpr.elements.push(objExpr);
-}
-function getUilintEslintConfigInfoFromSourceAst(source) {
+// src/commands/install/analyze.ts
+function safeParseJson(filePath) {
   try {
-    const mod = parseModule2(source);
-    const found = findExportedConfigArrayExpression(mod);
-    if (!found) {
-      return {
-        error: "Could not locate an exported ESLint flat config array (expected `export default [...]`, `export default defineConfig([...])`, `module.exports = [...]`, or `module.exports = defineConfig([...])`)."
-      };
-    }
-    const configuredRuleIds = collectConfiguredUilintRuleIdsFromConfigArray(
-      found.arrayExpr
-    );
-    const existingUilint = findExistingUilintRulesObject(found.arrayExpr);
-    const configured = configuredRuleIds.size > 0 || existingUilint.configObj !== null;
-    return {
-      info: { configuredRuleIds, configured },
-      mod,
-      arrayExpr: found.arrayExpr,
-      kind: found.kind
-    };
+    const content = readFileSync4(filePath, "utf-8");
+    return JSON.parse(content);
   } catch {
-    return {
-      error: "Unable to parse ESLint config as JavaScript. Please update it manually or simplify the config so it can be safely auto-modified."
-    };
-  }
-}
-function getUilintEslintConfigInfoFromSource(source) {
-  const ast = getUilintEslintConfigInfoFromSourceAst(source);
-  if ("error" in ast) {
-    const configuredRuleIds = extractConfiguredUilintRuleIds(source);
-    return {
-      configuredRuleIds,
-      configured: configuredRuleIds.size > 0
-    };
-  }
-  return ast.info;
-}
-function extractConfiguredUilintRuleIds(source) {
-  const ids = /* @__PURE__ */ new Set();
-  const re = /["']uilint\/([^"']+)["']\s*:/g;
-  for (const m of source.matchAll(re)) {
-    if (m[1]) ids.add(m[1]);
-  }
-  return ids;
-}
-function getMissingSelectedRules(selectedRules, configuredIds) {
-  return selectedRules.filter((r) => !configuredIds.has(r.id));
-}
-function buildDesiredRuleValueExpression(rule) {
-  if (rule.defaultOptions && rule.defaultOptions.length > 0) {
-    return `["${rule.defaultSeverity}", ...${JSON.stringify(
-      rule.defaultOptions,
-      null,
-      2
-    )}]`;
-  }
-  return `"${rule.defaultSeverity}"`;
-}
-function collectUilintRuleValueNodesFromConfigArray(arrayExpr) {
-  const out = /* @__PURE__ */ new Map();
-  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return out;
-  for (const el of arrayExpr.elements ?? []) {
-    if (!el || el.type !== "ObjectExpression") continue;
-    const rules = getObjectPropertyValue(el, "rules");
-    if (!rules || rules.type !== "ObjectExpression") continue;
-    for (const prop of rules.properties ?? []) {
-      if (!prop) continue;
-      if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
-      const key = prop.key;
-      if (!isStringLiteral(key)) continue;
-      const k = key.value;
-      if (typeof k !== "string" || !k.startsWith("uilint/")) continue;
-      const id = k.slice("uilint/".length);
-      if (!out.has(id)) out.set(id, prop.value);
-    }
-  }
-  return out;
-}
-function getRulesNeedingUpdate(selectedRules, configuredIds, arrayExpr) {
-  const existingVals = collectUilintRuleValueNodesFromConfigArray(arrayExpr);
-  return selectedRules.filter((r) => {
-    if (!configuredIds.has(r.id)) return false;
-    const existing = existingVals.get(r.id);
-    if (!existing) return true;
-    const desiredExpr = buildDesiredRuleValueExpression(r);
-    const desiredAst = parseExpression(desiredExpr).$ast;
-    return !astEquivalent(existing, desiredAst);
-  });
-}
-async function installEslintPlugin(opts) {
-  const configPath = findEslintConfigFile(opts.projectPath);
-  if (!configPath) {
-    return {
-      configFile: null,
-      modified: false,
-      missingRuleIds: [],
-      configured: false
-    };
-  }
-  const configFilename = getEslintConfigFilename(configPath);
-  const original = readFileSync4(configPath, "utf-8");
-  const isCommonJS = configPath.endsWith(".cjs");
-  const ast = getUilintEslintConfigInfoFromSourceAst(original);
-  if ("error" in ast) {
-    return {
-      configFile: configFilename,
-      modified: false,
-      missingRuleIds: [],
-      configured: false,
-      error: ast.error
-    };
-  }
-  const { info, mod, arrayExpr, kind } = ast;
-  const configuredIds = info.configuredRuleIds;
-  const missingRules = getMissingSelectedRules(
-    opts.selectedRules,
-    configuredIds
-  );
-  const rulesToUpdate = getRulesNeedingUpdate(
-    opts.selectedRules,
-    configuredIds,
-    arrayExpr
-  );
-  let rulesToApply = [];
-  if (!info.configured) {
-    rulesToApply = opts.selectedRules;
-  } else {
-    rulesToApply = [...missingRules, ...rulesToUpdate];
-    if (missingRules.length > 0 && !opts.force) {
-      const ok = await opts.confirmAddMissingRules?.(
-        configFilename,
-        missingRules
-      );
-      if (!ok) {
-        return {
-          configFile: configFilename,
-          modified: false,
-          missingRuleIds: missingRules.map((r) => r.id),
-          configured: true
-        };
-      }
-    }
-  }
-  if (rulesToApply.length === 0) {
-    return {
-      configFile: configFilename,
-      modified: false,
-      missingRuleIds: missingRules.map((r) => r.id),
-      configured: info.configured
-    };
-  }
-  let modifiedAst = false;
-  const localRulesDir = join4(opts.projectPath, ".uilint", "rules");
-  const workspaceRoot = findWorkspaceRoot(opts.projectPath);
-  const workspaceRulesDir = join4(workspaceRoot, ".uilint", "rules");
-  const rulesRoot = existsSync4(localRulesDir) ? opts.projectPath : workspaceRoot;
-  const isTypeScriptConfig = configPath.endsWith(".ts");
-  let fileExtension = isTypeScriptConfig ? "" : ".js";
-  let ruleImportNames;
-  if (kind === "esm") {
-    const result = addLocalRuleImportsAst(
-      mod,
-      rulesToApply,
-      configPath,
-      rulesRoot,
-      fileExtension
-    );
-    ruleImportNames = result.importNames;
-    if (result.changed) modifiedAst = true;
-  } else {
-    const result = addLocalRuleRequiresAst(
-      mod.$ast,
-      rulesToApply,
-      configPath,
-      rulesRoot,
-      fileExtension
-    );
-    ruleImportNames = result.importNames;
-    if (result.changed) modifiedAst = true;
-  }
-  if (ruleImportNames && ruleImportNames.size > 0) {
-    appendUilintConfigBlockToArray(arrayExpr, rulesToApply, ruleImportNames);
-    modifiedAst = true;
-  }
-  if (!info.configured) {
-    if (kind === "esm") {
-      mod.imports.$add({
-        imported: "createRule",
-        local: "createRule",
-        from: "uilint-eslint"
-      });
-      modifiedAst = true;
-    } else {
-      const stmtMod = parseModule2(
-        `const { createRule } = require("uilint-eslint");`
-      );
-      const stmt = stmtMod.$ast.body?.[0];
-      if (stmt) {
-        let insertAt = 0;
-        const first = mod.$ast.body?.[0];
-        if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
-          insertAt = 1;
-        }
-        mod.$ast.body.splice(insertAt, 0, stmt);
-        modifiedAst = true;
-      }
-    }
-  }
-  const updated = modifiedAst ? generateCode(mod).code : original;
-  if (updated !== original) {
-    writeFileSync(configPath, updated, "utf-8");
-    return {
-      configFile: configFilename,
-      modified: true,
-      missingRuleIds: missingRules.map((r) => r.id),
-      configured: getUilintEslintConfigInfoFromSource(updated).configured
-    };
+    return void 0;
   }
-  return {
-    configFile: configFilename,
-    modified: false,
-    missingRuleIds: missingRules.map((r) => r.id),
-    configured: getUilintEslintConfigInfoFromSource(updated).configured
-  };
 }
-async function uninstallEslintPlugin(options) {
-  const { projectPath } = options;
-  const configPath = findEslintConfigFile(projectPath);
-  if (!configPath) {
-    return {
-      success: true,
-      // Nothing to uninstall
-      modifiedFiles: []
-    };
-  }
-  try {
-    const original = readFileSync4(configPath, "utf-8");
-    let updated = original.replace(
-      /^import\s+\{[^}]*\}\s+from\s+["'][^"']*\.uilint\/rules[^"']*["'];?\s*$/gm,
-      ""
-    );
-    updated = updated.replace(
-      /^import\s+\w+\s+from\s+["'][^"']*\.uilint\/rules[^"']*["'];?\s*$/gm,
-      ""
-    );
-    updated = updated.replace(
-      /^import\s+\{[^}]*\}\s+from\s+["']uilint-eslint["'];?\s*$/gm,
-      ""
-    );
-    updated = updated.replace(
-      /^const\s+\{[^}]*createRule[^}]*\}\s*=\s*require\s*\(\s*["']uilint-eslint["']\s*\)\s*;?\s*$/gm,
-      ""
-    );
-    updated = updated.replace(
-      /["']uilint\/[^"']+["']\s*:\s*["'][^"']+["']\s*,?\s*/g,
-      ""
-    );
-    updated = updated.replace(
-      /["']uilint\/[^"']+["']\s*:\s*\[[^\]]*\]\s*,?\s*/g,
-      ""
-    );
-    updated = updated.replace(
-      /\{\s*plugins:\s*\{\s*uilint:\s*\{[^}]*\}[^}]*\}[^}]*rules:\s*\{[^}]*\}[^}]*\}\s*,?\s*/gs,
-      ""
-    );
-    updated = updated.replace(/\n{3,}/g, "\n\n");
-    if (updated !== original) {
-      writeFileSync(configPath, updated, "utf-8");
-      return {
-        success: true,
-        modifiedFiles: [configPath]
-      };
-    }
-    return {
-      success: true,
-      modifiedFiles: []
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
+function hasUilintOverlayInstalled(projectPath) {
+  const pkgPath = join4(projectPath, "package.json");
+  const pkg = safeParseJson(pkgPath);
+  if (!pkg) return false;
+  return !!(pkg.dependencies?.["uilint-react"] || pkg.devDependencies?.["uilint-react"]);
 }
-
-// src/commands/install/analyze.ts
 async function analyze(projectPath = process.cwd()) {
-  const workspaceRoot = findWorkspaceRoot2(projectPath);
+  const workspaceRoot = findWorkspaceRoot(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) {
-    nextApps.push({ projectPath, detection: directDetection });
+    nextApps.push({
+      projectPath,
+      detection: directDetection,
+      hasUilintOverlay: hasUilintOverlayInstalled(projectPath)
+    });
   } else {
     const matches = findNextAppRouterProjects(workspaceRoot, { maxDepth: 5 });
     for (const match of matches) {
       nextApps.push({
         projectPath: match.projectPath,
-        detection: match.detection
+        detection: match.detection,
+        hasUilintOverlay: hasUilintOverlayInstalled(match.projectPath)
       });
     }
   }
   const viteApps = [];
   const directVite = detectViteReact(projectPath);
   if (directVite) {
-    viteApps.push({ projectPath, detection: directVite });
+    viteApps.push({
+      projectPath,
+      detection: directVite,
+      hasUilintOverlay: hasUilintOverlayInstalled(projectPath)
+    });
   } else {
     const matches = findViteReactProjects(workspaceRoot, { maxDepth: 5 });
     for (const match of matches) {
       viteApps.push({
         projectPath: match.projectPath,
-        detection: match.detection
+        detection: match.detection,
+        hasUilintOverlay: hasUilintOverlayInstalled(match.projectPath)
       });
     }
   }
@@ -2204,7 +1646,7 @@ async function analyze(projectPath = process.cwd()) {
     if (eslintConfigPath) {
       eslintConfigFilename = getEslintConfigFilename(eslintConfigPath);
       try {
-        const source = readFileSync5(eslintConfigPath, "utf-8");
+        const source = readFileSync4(eslintConfigPath, "utf-8");
         const info = getUilintEslintConfigInfoFromSource(source);
         hasRules = info.configuredRuleIds.size > 0;
         configuredRuleIds = Array.from(info.configuredRuleIds);
@@ -2242,50 +1684,50 @@ async function analyze(projectPath = process.cwd()) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync10,
   mkdirSync,
-  writeFileSync as writeFileSync5,
-  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync8,
   unlinkSync,
   chmodSync,
   rmSync
 } from "fs";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
 
 // src/utils/react-inject.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6, relative as relative4 } from "path";
-import { parseModule as parseModule3, generateCode as generateCode2 } from "magicast";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { join as join5, relative as relative3 } from "path";
+import { parseModule as parseModule2, generateCode } 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";
@@ -2319,12 +1761,12 @@ function ensureNamedImport(program, from, name) {
       (s) => s?.type === "ImportSpecifier" && (s.imported?.name === name || s.imported?.value === name)
     );
     if (has) return { changed: false };
-    const spec = parseModule3(`import { ${name} } from "${from}";`).$ast.body?.[0]?.specifiers?.[0];
+    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 = parseModule3(`import { ${name} } from "${from}";`).$ast.body?.[0];
+  const importDecl = parseModule2(`import { ${name} } from "${from}";`).$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -2354,7 +1796,7 @@ function hasUILintDevtoolsJsx(program) {
 function addDevtoolsElementNextJs(program) {
   if (!program || program.type !== "Program") return { changed: false };
   if (hasUILintDevtoolsJsx(program)) return { changed: false };
-  const devtoolsMod = parseModule3(
+  const devtoolsMod = parseModule2(
     "const __uilint_devtools = <uilint-devtools />;"
   );
   const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -2392,12 +1834,12 @@ function addDevtoolsElementVite(program) {
     const arg0 = node.arguments?.[0];
     if (!arg0) return;
     if (arg0.type !== "JSXElement" && arg0.type !== "JSXFragment") return;
-    const devtoolsMod = parseModule3(
+    const devtoolsMod = parseModule2(
       "const __uilint_devtools = <uilint-devtools />;"
     );
     const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
     if (!devtoolsJsx) return;
-    const fragmentMod = parseModule3(
+    const fragmentMod = parseModule2(
       "const __fragment = <></>;"
     );
     const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -2417,7 +1859,7 @@ function ensureSideEffectImport(program, from) {
   if (!program || program.type !== "Program") return { changed: false };
   const existing = findImportDeclaration(program, from);
   if (existing) return { changed: false };
-  const importDecl = parseModule3(`import "${from}";`).$ast.body?.[0];
+  const importDecl = parseModule2(`import "${from}";`).$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -2433,7 +1875,7 @@ function ensureSideEffectImport(program, from) {
 function addDevtoolsToClientComponent(program) {
   if (!program || program.type !== "Program") return { changed: false };
   if (hasUILintDevtoolsJsx(program)) return { changed: false };
-  const devtoolsMod = parseModule3(
+  const devtoolsMod = parseModule2(
     "const __uilint_devtools = <uilint-devtools />;"
   );
   const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -2459,7 +1901,7 @@ function addDevtoolsToClientComponent(program) {
     const arg = node.argument;
     if (!arg) return;
     if (arg.type !== "JSXElement" && arg.type !== "JSXFragment") return;
-    const fragmentMod = parseModule3("const __fragment = <></>;");
+    const fragmentMod = parseModule2("const __fragment = <></>;");
     const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
     if (!fragmentJsx) return;
     fragmentJsx.children = [arg, devtoolsJsx];
@@ -2514,7 +1956,7 @@ function wrapChildrenWithProviders(program, providersImportPath) {
       (child) => child?.type === "JSXExpressionContainer" && child.expression?.type === "Identifier" && child.expression.name === "children"
     );
     if (childrenIndex === -1) return;
-    const providersMod = parseModule3(
+    const providersMod = parseModule2(
       "const __providers = <Providers>{children}</Providers>;"
     );
     const providersJsx = providersMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -2532,8 +1974,8 @@ function wrapChildrenWithProviders(program, providersImportPath) {
 function findLayoutFile2(projectPath, appRoot) {
   const extensions = [".tsx", ".jsx", ".ts", ".js"];
   for (const ext of extensions) {
-    const layoutPath = join6(projectPath, appRoot, `layout${ext}`);
-    if (existsSync6(layoutPath)) return layoutPath;
+    const layoutPath = join5(projectPath, appRoot, `layout${ext}`);
+    if (existsSync5(layoutPath)) return layoutPath;
   }
   return null;
 }
@@ -2544,32 +1986,32 @@ async function createProvidersAndModifyLayout(projectPath, appRoot) {
   }
   const isTypeScript = layoutPath.endsWith(".tsx") || layoutPath.endsWith(".ts");
   const providersExt = isTypeScript ? ".tsx" : ".jsx";
-  const providersPath = join6(projectPath, appRoot, `providers${providersExt}`);
-  if (existsSync6(providersPath)) {
+  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 = readFileSync6(layoutPath, "utf-8");
+  writeFileSync(providersPath, providersContent, "utf-8");
+  const layoutContent = readFileSync5(layoutPath, "utf-8");
   let layoutMod;
   try {
-    layoutMod = parseModule3(layoutContent);
+    layoutMod = parseModule2(layoutContent);
   } catch {
     throw new Error(
-      `Unable to parse ${relative4(projectPath, layoutPath)} as JavaScript/TypeScript.`
+      `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");
+    const updatedLayout = generateCode(layoutMod).code;
+    writeFileSync(layoutPath, updatedLayout, "utf-8");
   }
   return {
-    providersFile: relative4(projectPath, providersPath),
-    layoutFile: relative4(projectPath, layoutPath),
+    providersFile: relative3(projectPath, providersPath),
+    layoutFile: relative3(projectPath, layoutPath),
     modified: true
   };
 }
@@ -2581,8 +2023,8 @@ async function installReactUILintOverlay(opts) {
     );
     const modifiedFiles = [];
     if (result.modified) {
-      modifiedFiles.push(join6(opts.projectPath, result.providersFile));
-      modifiedFiles.push(join6(opts.projectPath, result.layoutFile));
+      modifiedFiles.push(join5(opts.projectPath, result.providersFile));
+      modifiedFiles.push(join5(opts.projectPath, result.layoutFile));
     }
     return {
       targetFile: result.providersFile,
@@ -2594,14 +2036,14 @@ async function installReactUILintOverlay(opts) {
   }
   if (opts.targetFile) {
     const absTarget2 = opts.targetFile;
-    const relTarget = relative4(opts.projectPath, absTarget2);
-    if (!existsSync6(absTarget2)) {
+    const relTarget = relative3(opts.projectPath, absTarget2);
+    if (!existsSync5(absTarget2)) {
       throw new Error(`Target file not found: ${relTarget}`);
     }
-    const original2 = readFileSync6(absTarget2, "utf-8");
+    const original2 = readFileSync5(absTarget2, "utf-8");
     let mod2;
     try {
-      mod2 = parseModule3(original2);
+      mod2 = parseModule2(original2);
     } catch {
       throw new Error(
         `Unable to parse ${relTarget} as JavaScript/TypeScript. Please update it manually.`
@@ -2624,10 +2066,10 @@ async function installReactUILintOverlay(opts) {
     if (importRes2.changed) changed2 = true;
     const addRes2 = addDevtoolsToClientComponent(program2);
     if (addRes2.changed) changed2 = true;
-    const updated2 = changed2 ? generateCode2(mod2).code : original2;
+    const updated2 = changed2 ? generateCode(mod2).code : original2;
     const modified2 = updated2 !== original2;
     if (modified2) {
-      writeFileSync2(absTarget2, updated2, "utf-8");
+      writeFileSync(absTarget2, updated2, "utf-8");
     }
     return {
       targetFile: relTarget,
@@ -2648,11 +2090,11 @@ async function installReactUILintOverlay(opts) {
   } else {
     chosen = candidates[0];
   }
-  const absTarget = join6(opts.projectPath, chosen);
-  const original = readFileSync6(absTarget, "utf-8");
+  const absTarget = join5(opts.projectPath, chosen);
+  const original = readFileSync5(absTarget, "utf-8");
   let mod;
   try {
-    mod = parseModule3(original);
+    mod = parseModule2(original);
   } catch {
     throw new Error(
       `Unable to parse ${chosen} as JavaScript/TypeScript. Please update it manually.`
@@ -2668,10 +2110,10 @@ async function installReactUILintOverlay(opts) {
   const mode = opts.mode ?? "next";
   const addRes = mode === "vite" ? addDevtoolsElementVite(program) : addDevtoolsElementNextJs(program);
   if (addRes.changed) changed = true;
-  const updated = changed ? generateCode2(mod).code : original;
+  const updated = changed ? generateCode(mod).code : original;
   const modified = updated !== original;
   if (modified) {
-    writeFileSync2(absTarget, updated, "utf-8");
+    writeFileSync(absTarget, updated, "utf-8");
   }
   return {
     targetFile: chosen,
@@ -2685,10 +2127,10 @@ async function uninstallReactUILintOverlay(options) {
   const candidates = getDefaultCandidates(projectPath, appRoot);
   const modifiedFiles = [];
   for (const candidate of candidates) {
-    const absPath = join6(projectPath, candidate);
-    if (!existsSync6(absPath)) continue;
+    const absPath = join5(projectPath, candidate);
+    if (!existsSync5(absPath)) continue;
     try {
-      const original = readFileSync6(absPath, "utf-8");
+      const original = readFileSync5(absPath, "utf-8");
       let updated = original.replace(
         /^import\s+["']uilint-react\/devtools["'];?\s*$/gm,
         ""
@@ -2706,7 +2148,7 @@ async function uninstallReactUILintOverlay(options) {
       );
       updated = updated.replace(/\n{3,}/g, "\n\n");
       if (updated !== original) {
-        writeFileSync2(absPath, updated, "utf-8");
+        writeFileSync(absPath, updated, "utf-8");
         modifiedFiles.push(absPath);
       }
     } catch {
@@ -2719,14 +2161,14 @@ async function uninstallReactUILintOverlay(options) {
 }
 
 // src/utils/next-config-inject.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
-import { parseModule as parseModule4, generateCode as generateCode3 } from "magicast";
-var CONFIG_EXTENSIONS2 = [".ts", ".mjs", ".js", ".cjs"];
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { parseModule as parseModule3, generateCode as generateCode2 } from "magicast";
+var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
 function findNextConfigFile(projectPath) {
-  for (const ext of CONFIG_EXTENSIONS2) {
-    const configPath = join7(projectPath, `next.config${ext}`);
-    if (existsSync7(configPath)) {
+  for (const ext of CONFIG_EXTENSIONS) {
+    const configPath = join6(projectPath, `next.config${ext}`);
+    if (existsSync6(configPath)) {
       return configPath;
     }
   }
@@ -2736,10 +2178,10 @@ function getNextConfigFilename(configPath) {
   const parts = configPath.split("/");
   return parts[parts.length - 1] || "next.config.ts";
 }
-function isIdentifier2(node, name) {
+function isIdentifier(node, name) {
   return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
 }
-function isStringLiteral2(node) {
+function isStringLiteral(node) {
   return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
 }
 function ensureEsmWithJsxLocImport(program) {
@@ -2752,12 +2194,12 @@ function ensureEsmWithJsxLocImport(program) {
       (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "withJsxLoc" || sp.imported?.value === "withJsxLoc")
     );
     if (has) return { changed: false };
-    const spec = parseModule4('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0]?.specifiers?.[0];
+    const spec = parseModule3('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0]?.specifiers?.[0];
     if (!spec) return { changed: false };
     existing.specifiers = [...existing.specifiers ?? [], spec];
     return { changed: true };
   }
-  const importDecl = parseModule4('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0];
+  const importDecl = parseModule3('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -2773,14 +2215,14 @@ function ensureCjsWithJsxLocRequire(program) {
     if (stmt?.type !== "VariableDeclaration") continue;
     for (const decl of stmt.declarations ?? []) {
       const init = decl?.init;
-      if (init?.type === "CallExpression" && isIdentifier2(init.callee, "require") && isStringLiteral2(init.arguments?.[0]) && init.arguments[0].value === "jsx-loc-plugin") {
+      if (init?.type === "CallExpression" && isIdentifier(init.callee, "require") && isStringLiteral(init.arguments?.[0]) && init.arguments[0].value === "jsx-loc-plugin") {
         if (decl.id?.type === "ObjectPattern") {
           const has = (decl.id.properties ?? []).some((p) => {
             if (p?.type !== "ObjectProperty" && p?.type !== "Property") return false;
-            return isIdentifier2(p.key, "withJsxLoc");
+            return isIdentifier(p.key, "withJsxLoc");
           });
           if (has) return { changed: false };
-          const prop = parseModule4('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
+          const prop = parseModule3('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
           if (!prop) return { changed: false };
           decl.id.properties = [...decl.id.properties ?? [], prop];
           return { changed: true };
@@ -2789,7 +2231,7 @@ function ensureCjsWithJsxLocRequire(program) {
       }
     }
   }
-  const reqDecl = parseModule4('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0];
+  const reqDecl = parseModule3('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0];
   if (!reqDecl) return { changed: false };
   program.body.unshift(reqDecl);
   return { changed: true };
@@ -2801,7 +2243,7 @@ function wrapEsmExportDefault(program) {
   );
   if (!exportDecl) return { changed: false };
   const decl = exportDecl.declaration;
-  if (decl?.type === "CallExpression" && isIdentifier2(decl.callee, "withJsxLoc")) {
+  if (decl?.type === "CallExpression" && isIdentifier(decl.callee, "withJsxLoc")) {
     return { changed: false };
   }
   exportDecl.declaration = {
@@ -2819,9 +2261,9 @@ function wrapCjsModuleExports(program) {
     if (!expr || expr.type !== "AssignmentExpression") continue;
     const left = expr.left;
     const right = expr.right;
-    const isModuleExports = left?.type === "MemberExpression" && isIdentifier2(left.object, "module") && isIdentifier2(left.property, "exports");
+    const isModuleExports = left?.type === "MemberExpression" && isIdentifier(left.object, "module") && isIdentifier(left.property, "exports");
     if (!isModuleExports) continue;
-    if (right?.type === "CallExpression" && isIdentifier2(right.callee, "withJsxLoc")) {
+    if (right?.type === "CallExpression" && isIdentifier(right.callee, "withJsxLoc")) {
       return { changed: false };
     }
     expr.right = {
@@ -2839,10 +2281,10 @@ async function installJsxLocPlugin(opts) {
     return { configFile: null, modified: false, modifiedFiles: [] };
   }
   const configFilename = getNextConfigFilename(configPath);
-  const original = readFileSync7(configPath, "utf-8");
+  const original = readFileSync6(configPath, "utf-8");
   let mod;
   try {
-    mod = parseModule4(original);
+    mod = parseModule3(original);
   } catch {
     return { configFile: configFilename, modified: false, modifiedFiles: [] };
   }
@@ -2860,9 +2302,9 @@ async function installJsxLocPlugin(opts) {
     const wrapRes = wrapEsmExportDefault(program);
     if (wrapRes.changed) changed = true;
   }
-  const updated = changed ? generateCode3(mod).code : original;
+  const updated = changed ? generateCode2(mod).code : original;
   if (updated !== original) {
-    writeFileSync3(configPath, updated, "utf-8");
+    writeFileSync2(configPath, updated, "utf-8");
     return { configFile: configFilename, modified: true, modifiedFiles: [configPath] };
   }
   return { configFile: configFilename, modified: false, modifiedFiles: [] };
@@ -2877,7 +2319,7 @@ async function uninstallJsxLocPlugin(options) {
     };
   }
   try {
-    const original = readFileSync7(configPath, "utf-8");
+    const original = readFileSync6(configPath, "utf-8");
     let updated = original.replace(
       /^import\s+\{[^}]*withJsxLoc[^}]*\}\s+from\s+["']jsx-loc-plugin\/next["'];?\s*$/gm,
       ""
@@ -2896,7 +2338,7 @@ async function uninstallJsxLocPlugin(options) {
     );
     updated = updated.replace(/\n{3,}/g, "\n\n");
     if (updated !== original) {
-      writeFileSync3(configPath, updated, "utf-8");
+      writeFileSync2(configPath, updated, "utf-8");
       return {
         success: true,
         modifiedFiles: [configPath]
@@ -2915,14 +2357,14 @@ async function uninstallJsxLocPlugin(options) {
 }
 
 // src/utils/vite-config-inject.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
-import { parseModule as parseModule5, generateCode as generateCode4 } from "magicast";
-var CONFIG_EXTENSIONS3 = [".ts", ".mjs", ".js", ".cjs"];
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+import { parseModule as parseModule4, generateCode as generateCode3 } from "magicast";
+var CONFIG_EXTENSIONS2 = [".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;
+  for (const ext of CONFIG_EXTENSIONS2) {
+    const configPath = join7(projectPath, `vite.config${ext}`);
+    if (existsSync7(configPath)) return configPath;
   }
   return null;
 }
@@ -2930,10 +2372,10 @@ function getViteConfigFilename(configPath) {
   const parts = configPath.split("/");
   return parts[parts.length - 1] || "vite.config.ts";
 }
-function isIdentifier3(node, name) {
+function isIdentifier2(node, name) {
   return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
 }
-function isStringLiteral3(node) {
+function isStringLiteral2(node) {
   return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
 }
 function unwrapExpression(expr) {
@@ -2965,7 +2407,7 @@ function findExportedConfigObjectExpression(mod) {
     if (decl.type === "ObjectExpression") {
       return { kind: "esm", objExpr: decl, program };
     }
-    if (decl.type === "CallExpression" && isIdentifier3(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ObjectExpression") {
+    if (decl.type === "CallExpression" && isIdentifier2(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ObjectExpression") {
       return {
         kind: "esm",
         objExpr: unwrapExpression(decl.arguments?.[0]),
@@ -2980,12 +2422,12 @@ function findExportedConfigObjectExpression(mod) {
     if (!expr || expr.type !== "AssignmentExpression") continue;
     const left = expr.left;
     const right = unwrapExpression(expr.right);
-    const isModuleExports = left?.type === "MemberExpression" && isIdentifier3(left.object, "module") && isIdentifier3(left.property, "exports");
+    const isModuleExports = left?.type === "MemberExpression" && isIdentifier2(left.object, "module") && isIdentifier2(left.property, "exports");
     if (!isModuleExports) continue;
     if (right?.type === "ObjectExpression") {
       return { kind: "cjs", objExpr: right, program };
     }
-    if (right?.type === "CallExpression" && isIdentifier3(right.callee, "defineConfig") && unwrapExpression(right.arguments?.[0])?.type === "ObjectExpression") {
+    if (right?.type === "CallExpression" && isIdentifier2(right.callee, "defineConfig") && unwrapExpression(right.arguments?.[0])?.type === "ObjectExpression") {
       return {
         kind: "cjs",
         objExpr: unwrapExpression(right.arguments?.[0]),
@@ -3001,7 +2443,7 @@ function getObjectProperty(obj, keyName) {
     if (!prop) continue;
     if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
     const key = prop.key;
-    const keyMatch = key?.type === "Identifier" && key.name === keyName || isStringLiteral3(key) && key.value === keyName;
+    const keyMatch = key?.type === "Identifier" && key.name === keyName || isStringLiteral2(key) && key.value === keyName;
     if (keyMatch) return prop;
   }
   return null;
@@ -3016,12 +2458,12 @@ function ensureEsmJsxLocImport(program) {
       (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "jsxLoc" || sp.imported?.value === "jsxLoc")
     );
     if (has) return { changed: false };
-    const spec = parseModule5('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0]?.specifiers?.[0];
+    const spec = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0]?.specifiers?.[0];
     if (!spec) return { changed: false };
     existing.specifiers = [...existing.specifiers ?? [], spec];
     return { changed: true };
   }
-  const importDecl = parseModule5('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
+  const importDecl = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -3037,14 +2479,14 @@ function ensureCjsJsxLocRequire(program) {
     if (stmt?.type !== "VariableDeclaration") continue;
     for (const decl of stmt.declarations ?? []) {
       const init = decl?.init;
-      if (init?.type === "CallExpression" && isIdentifier3(init.callee, "require") && isStringLiteral3(init.arguments?.[0]) && init.arguments[0].value === "jsx-loc-plugin/vite") {
+      if (init?.type === "CallExpression" && isIdentifier2(init.callee, "require") && isStringLiteral2(init.arguments?.[0]) && init.arguments[0].value === "jsx-loc-plugin/vite") {
         if (decl.id?.type === "ObjectPattern") {
           const has = (decl.id.properties ?? []).some((p) => {
             if (p?.type !== "ObjectProperty" && p?.type !== "Property") return false;
-            return isIdentifier3(p.key, "jsxLoc");
+            return isIdentifier2(p.key, "jsxLoc");
           });
           if (has) return { changed: false };
-          const prop = parseModule5('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
+          const prop = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
           if (!prop) return { changed: false };
           decl.id.properties = [...decl.id.properties ?? [], prop];
           return { changed: true };
@@ -3053,7 +2495,7 @@ function ensureCjsJsxLocRequire(program) {
       }
     }
   }
-  const reqDecl = parseModule5('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0];
+  const reqDecl = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0];
   if (!reqDecl) return { changed: false };
   program.body.unshift(reqDecl);
   return { changed: true };
@@ -3063,16 +2505,16 @@ function pluginsHasJsxLoc(arr) {
   for (const el of arr.elements ?? []) {
     const e = unwrapExpression(el);
     if (!e) continue;
-    if (e.type === "CallExpression" && isIdentifier3(e.callee, "jsxLoc")) return true;
+    if (e.type === "CallExpression" && isIdentifier2(e.callee, "jsxLoc")) return true;
   }
   return false;
 }
 function ensurePluginsContainsJsxLoc(configObj) {
   const pluginsProp = getObjectProperty(configObj, "plugins");
   if (!pluginsProp) {
-    const prop = parseModule5("export default { plugins: [jsxLoc()] };").$ast.body?.find((s) => s.type === "ExportDefaultDeclaration")?.declaration?.properties?.find((p) => {
+    const prop = parseModule4("export default { plugins: [jsxLoc()] };").$ast.body?.find((s) => s.type === "ExportDefaultDeclaration")?.declaration?.properties?.find((p) => {
       const k = p?.key;
-      return k?.type === "Identifier" && k.name === "plugins" || isStringLiteral3(k) && k.value === "plugins";
+      return k?.type === "Identifier" && k.name === "plugins" || isStringLiteral2(k) && k.value === "plugins";
     });
     if (!prop) return { changed: false };
     configObj.properties = [...configObj.properties ?? [], prop];
@@ -3082,12 +2524,12 @@ function ensurePluginsContainsJsxLoc(configObj) {
   if (!value) return { changed: false };
   if (value.type === "ArrayExpression") {
     if (pluginsHasJsxLoc(value)) return { changed: false };
-    const jsxLocCall2 = parseModule5("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+    const jsxLocCall2 = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
     if (!jsxLocCall2) return { changed: false };
     value.elements.push(jsxLocCall2);
     return { changed: true };
   }
-  const jsxLocCall = parseModule5("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+  const jsxLocCall = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
   if (!jsxLocCall) return { changed: false };
   const spread = { type: "SpreadElement", argument: value };
   pluginsProp.value = { type: "ArrayExpression", elements: [spread, jsxLocCall] };
@@ -3097,11 +2539,11 @@ async function installViteJsxLocPlugin(opts) {
   const configPath = findViteConfigFile2(opts.projectPath);
   if (!configPath) return { configFile: null, modified: false, modifiedFiles: [] };
   const configFilename = getViteConfigFilename(configPath);
-  const original = readFileSync8(configPath, "utf-8");
+  const original = readFileSync7(configPath, "utf-8");
   const isCjs = configPath.endsWith(".cjs");
   let mod;
   try {
-    mod = parseModule5(original);
+    mod = parseModule4(original);
   } catch {
     return { configFile: configFilename, modified: false, modifiedFiles: [] };
   }
@@ -3117,9 +2559,9 @@ async function installViteJsxLocPlugin(opts) {
   }
   const pluginsRes = ensurePluginsContainsJsxLoc(found.objExpr);
   if (pluginsRes.changed) changed = true;
-  const updated = changed ? generateCode4(mod).code : original;
+  const updated = changed ? generateCode3(mod).code : original;
   if (updated !== original) {
-    writeFileSync4(configPath, updated, "utf-8");
+    writeFileSync3(configPath, updated, "utf-8");
     return { configFile: configFilename, modified: true, modifiedFiles: [configPath] };
   }
   return { configFile: configFilename, modified: false, modifiedFiles: [] };
@@ -3134,7 +2576,7 @@ async function uninstallViteJsxLocPlugin(options) {
     };
   }
   try {
-    const original = readFileSync8(configPath, "utf-8");
+    const original = readFileSync7(configPath, "utf-8");
     let updated = original.replace(
       /^import\s+\{[^}]*jsxLoc[^}]*\}\s+from\s+["']jsx-loc-plugin\/vite["'];?\s*$/gm,
       ""
@@ -3150,7 +2592,7 @@ async function uninstallViteJsxLocPlugin(options) {
     updated = updated.replace(/jsxLoc\s*\(\s*\)\s*,?\s*/g, "");
     updated = updated.replace(/\n{3,}/g, "\n\n");
     if (updated !== original) {
-      writeFileSync4(configPath, updated, "utf-8");
+      writeFileSync3(configPath, updated, "utf-8");
       return {
         success: true,
         modifiedFiles: [configPath]
@@ -3169,9 +2611,9 @@ async function uninstallViteJsxLocPlugin(options) {
 }
 
 // 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
  *
@@ -3627,23 +3069,23 @@ 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
   );
@@ -3651,9 +3093,9 @@ async function installNextUILintRoutes(opts) {
 async function uninstallNextUILintRoutes(options) {
   const { projectPath, appRoot } = options;
   const { rm } = await import("fs/promises");
-  const baseAbs = join9(projectPath, appRoot, "api", ".uilint");
+  const baseAbs = join8(projectPath, appRoot, "api", ".uilint");
   try {
-    if (existsSync9(baseAbs)) {
+    if (existsSync8(baseAbs)) {
       await rm(baseAbs, { recursive: true, force: true });
     }
     return { success: true };
@@ -3666,17 +3108,17 @@ async function uninstallNextUILintRoutes(options) {
 }
 
 // src/utils/prettier.ts
-import { existsSync as existsSync10, utimesSync } from "fs";
+import { existsSync as existsSync9, utimesSync } from "fs";
 import { spawn } from "child_process";
-import { join as join10, dirname as dirname4 } from "path";
+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 parent = dirname4(dir);
+    const binPath = join9(dir, "node_modules", ".bin", "prettier");
+    if (existsSync9(binPath)) return binPath;
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3807,7 +3249,7 @@ function touchFiles(filePaths) {
   const now = /* @__PURE__ */ new Date();
   for (const filePath of filePaths) {
     try {
-      if (existsSync10(filePath)) {
+      if (existsSync9(filePath)) {
         utimesSync(filePath, now, now);
       }
     } catch {
@@ -3816,6 +3258,7 @@ function touchFiles(filePaths) {
 }
 
 // src/commands/install/execute.ts
+import { findWorkspaceRoot as findWorkspaceRoot2 } from "uilint-core/node";
 async function executeAction(action, options) {
   const { dryRun = false } = options;
   try {
@@ -3828,7 +3271,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 };
@@ -3841,11 +3284,11 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname5(action.path);
-        if (!existsSync11(dir)) {
+        const dir = dirname4(action.path);
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
-        writeFileSync5(action.path, action.content, "utf-8");
+        writeFileSync4(action.path, action.content, "utf-8");
         if (action.permissions) {
           chmodSync(action.path, action.permissions);
         }
@@ -3860,18 +3303,18 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync11(action.path)) {
+        if (existsSync10(action.path)) {
           try {
-            existing = JSON.parse(readFileSync9(action.path, "utf-8"));
+            existing = JSON.parse(readFileSync8(action.path, "utf-8"));
           } catch {
           }
         }
         const merged = deepMerge(existing, action.merge);
-        const dir = dirname5(action.path);
-        if (!existsSync11(dir)) {
+        const dir = dirname4(action.path);
+        if (!existsSync10(dir)) {
           mkdirSync(dir, { recursive: true });
         }
-        writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
+        writeFileSync4(action.path, JSON.stringify(merged, null, 2), "utf-8");
         return { action, success: true };
       }
       case "delete_file": {
@@ -3882,7 +3325,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 };
@@ -3895,12 +3338,12 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync11(action.path)) {
-          const content = readFileSync9(action.path, "utf-8");
+        if (existsSync10(action.path)) {
+          const content = readFileSync8(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
           }
-          writeFileSync5(action.path, content + action.content, "utf-8");
+          writeFileSync4(action.path, content + action.content, "utf-8");
         }
         return { action, success: true };
       }
@@ -3916,6 +3359,9 @@ async function executeAction(action, options) {
       case "inject_vite_config": {
         return await executeInjectViteConfig(action, options);
       }
+      case "inject_vitest_coverage": {
+        return await executeInjectVitestCoverage(action, options);
+      }
       case "install_next_routes": {
         return await executeInstallNextRoutes(action, options);
       }
@@ -4027,6 +3473,31 @@ async function executeInjectViteConfig(action, options) {
     modifiedFiles: result.modifiedFiles
   };
 }
+async function executeInjectVitestCoverage(action, options) {
+  const { dryRun = false } = options;
+  const setup = detectCoverageSetup(action.projectPath);
+  const vitestConfigPath = action.vitestConfigPath || setup.vitestConfigPath;
+  if (!vitestConfigPath) {
+    return {
+      action,
+      success: true
+      // Don't fail the install, coverage config is optional
+    };
+  }
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject coverage config into vitest.config: ${vitestConfigPath}`
+    };
+  }
+  const modified = injectCoverageConfig(vitestConfigPath);
+  return {
+    action,
+    success: true,
+    modifiedFiles: modified ? [vitestConfigPath] : void 0
+  };
+}
 async function executeInjectNextConfig(action, options) {
   const { dryRun = false } = options;
   if (dryRun) {
@@ -4169,7 +3640,7 @@ async function executeRemoveDirectory(action, options) {
       wouldDo: `Remove directory: ${action.path}`
     };
   }
-  if (existsSync11(action.path)) {
+  if (existsSync10(action.path)) {
     rmSync(action.path, { recursive: true, force: true });
   }
   return { action, success: true };
@@ -4316,6 +3787,36 @@ function getProjectPathFromActions(actionsPerformed) {
   }
   return void 0;
 }
+function normalizePnpmWorkspaceUilintSpecs(packagePath, packages) {
+  const workspaceRoot = findWorkspaceRoot2(packagePath);
+  if (!existsSync10(join10(workspaceRoot, "pnpm-workspace.yaml"))) return packages;
+  const touchesUilint = packages.some((p) => p === "uilint-eslint" || p.startsWith("uilint-"));
+  if (!touchesUilint) return packages;
+  const pkgJsonPath = join10(packagePath, "package.json");
+  if (!existsSync10(pkgJsonPath)) return packages;
+  let pkg = null;
+  try {
+    pkg = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+  } catch {
+    return packages;
+  }
+  const wanted = ["uilint-core", "uilint-eslint", "uilint-react"];
+  const present = /* @__PURE__ */ new Set();
+  for (const name of wanted) {
+    const range = pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name];
+    if (typeof range === "string") {
+      present.add(name);
+    }
+  }
+  if (present.size === 0) return packages;
+  const filtered = packages.filter(
+    (p) => !/^uilint-(core|eslint|react)(@.+)?$/.test(p)
+  );
+  for (const name of present) {
+    filtered.push(`${name}@workspace:*`);
+  }
+  return filtered;
+}
 async function execute(plan, options = {}) {
   const {
     dryRun = false,
@@ -4339,13 +3840,14 @@ async function execute(plan, options = {}) {
       continue;
     }
     try {
+      const pkgs = dep.packageManager === "pnpm" ? normalizePnpmWorkspaceUilintSpecs(dep.packagePath, dep.packages) : dep.packages;
       await installDependencies2(
         dep.packageManager,
         dep.packagePath,
-        dep.packages
+        pkgs
       );
       dependencyResults.push({
-        install: dep,
+        install: { ...dep, packages: pkgs },
         success: true
       });
     } catch (error) {
@@ -4481,7 +3983,7 @@ var genstyleguideInstaller = {
 };
 
 // src/commands/install/installers/skill.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { join as join12 } from "path";
 var skillInstaller = {
   id: "skill",
@@ -4494,7 +3996,7 @@ var skillInstaller = {
   getTargets(project) {
     const skillsDir = join12(project.cursorDir.path, "skills", "ui-consistency-enforcer");
     const skillMdPath = join12(skillsDir, "SKILL.md");
-    const isInstalled = existsSync12(skillMdPath);
+    const isInstalled = existsSync11(skillMdPath);
     return [
       {
         id: "ui-consistency-skill",
@@ -4608,9 +4110,6 @@ function getUpgradeInfo(configuredRuleIds) {
     summary
   };
 }
-function toInstallSpecifier(pkgName) {
-  return pkgName;
-}
 function formatRuleOption(rule) {
   const severityBadge = rule.defaultSeverity === "error" ? pc.red("error") : pc.yellow("warn");
   return {
@@ -4747,6 +4246,9 @@ var eslintInstaller = {
     const warnCount = configuredRules.filter(
       (r) => r.severity === "warn"
     ).length;
+    const hasSemanticDuplicates = configuredRules.some(
+      (cr) => cr.rule.id === "no-semantic-duplicates"
+    );
     log("");
     note(
       configuredRules.map(
@@ -4754,6 +4256,19 @@ var eslintInstaller = {
       ).join("\n"),
       `Selected ${configuredRules.length} rules (${errorCount} errors, ${warnCount} warnings)`
     );
+    if (hasSemanticDuplicates) {
+      log("");
+      log(
+        pc.yellow(
+          "\u26A0\uFE0F  The no-semantic-duplicates rule requires a semantic index."
+        )
+      );
+      log(
+        pc.dim(
+          "   Run 'uilint duplicates index' in each target app to build it."
+        )
+      );
+    }
     return { configuredRules };
   },
   plan(targets, config, project) {
@@ -4777,7 +4292,14 @@ var eslintInstaller = {
       dependencies.push({
         packagePath: target.path,
         packageManager: detectPackageManager(target.path),
-        packages: [toInstallSpecifier("uilint-eslint"), "typescript-eslint"]
+        packages: [
+          toInstallSpecifier("uilint-eslint", {
+            preferWorkspaceProtocol: project.packageManager === "pnpm",
+            workspaceRoot: project.workspaceRoot,
+            targetProjectPath: target.path
+          }),
+          "typescript-eslint"
+        ]
       });
       actions.push({
         type: "inject_eslint",
@@ -4854,8 +4376,7 @@ var viteOverlayInstaller = {
       label: app.projectPath.split("/").pop() || app.projectPath,
       path: app.projectPath,
       hint: "React + Vite",
-      isInstalled: false
-      // TODO: Detect if already installed
+      isInstalled: app.hasUilintOverlay
     }));
   },
   plan(targets, config, project) {
@@ -4863,13 +4384,27 @@ var viteOverlayInstaller = {
     const dependencies = [];
     if (targets.length === 0) return { actions, dependencies };
     const target = targets[0];
-    const appInfo = project.viteApps.find((app) => app.projectPath === target.path);
+    const appInfo = project.viteApps.find(
+      (app) => app.projectPath === target.path
+    );
     if (!appInfo) return { actions, dependencies };
     const { projectPath, detection } = appInfo;
     dependencies.push({
       packagePath: projectPath,
       packageManager: project.packageManager,
-      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+      packages: [
+        toInstallSpecifier("uilint-react", {
+          preferWorkspaceProtocol: project.packageManager === "pnpm",
+          workspaceRoot: project.workspaceRoot,
+          targetProjectPath: projectPath
+        }),
+        toInstallSpecifier("uilint-core", {
+          preferWorkspaceProtocol: project.packageManager === "pnpm",
+          workspaceRoot: project.workspaceRoot,
+          targetProjectPath: projectPath
+        }),
+        "jsx-loc-plugin"
+      ]
     });
     actions.push({
       type: "inject_react",
@@ -4947,6 +4482,105 @@ registerInstaller(viteOverlayInstaller);
 
 // src/commands/install-ui.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
+function limitList(items, max) {
+  if (items.length <= max) return items;
+  return [...items.slice(0, max), pc.dim(`\u2026and ${items.length - max} more`)];
+}
+function printInstallReport(result, testCoverageResult) {
+  const failedDeps = result.dependencyResults.filter((r) => !r.success);
+  const okDeps = result.dependencyResults.filter((r) => r.success);
+  const failedActions = result.actionsPerformed.filter((r) => !r.success);
+  const okActions = result.actionsPerformed.filter((r) => r.success);
+  if (result.success) {
+    console.log(`
+${pc.green("\u2713")} Operation completed successfully`);
+  } else {
+    console.log(`
+${pc.yellow("\u26A0")} Operation completed with errors`);
+  }
+  const { summary } = result;
+  const installed = summary.installedItems.map((x) => String(x));
+  const created = summary.filesCreated;
+  const modified = summary.filesModified;
+  const deleted = summary.filesDeleted;
+  if (installed.length > 0) {
+    console.log(`
+${pc.bold("Installed:")}`);
+    for (const item of installed) console.log(`- ${pc.green("\u2713")} ${item}`);
+  }
+  if (summary.eslintTargets.length > 0) {
+    console.log(`
+${pc.bold("ESLint configured:")}`);
+    for (const t of summary.eslintTargets) {
+      console.log(
+        `- ${pc.green("\u2713")} ${t.displayName} ${pc.dim(`(${t.configFile})`)}`
+      );
+    }
+  }
+  if (created.length + modified.length + deleted.length > 0) {
+    console.log(`
+${pc.bold("Files:")}`);
+    for (const p of limitList(created, 20))
+      console.log(`- ${pc.green("+")} ${p}`);
+    for (const p of limitList(modified, 20))
+      console.log(`- ${pc.yellow("~")} ${p}`);
+    for (const p of limitList(deleted, 20))
+      console.log(`- ${pc.red("-")} ${p}`);
+  }
+  if (summary.dependenciesInstalled.length > 0) {
+    console.log(`
+${pc.bold("Dependencies installed:")}`);
+    for (const d of summary.dependenciesInstalled) {
+      console.log(
+        `- ${pc.green("\u2713")} ${d.packagePath} ${pc.dim(`\u2190 ${d.packages.join(", ")}`)}`
+      );
+    }
+  }
+  if (testCoverageResult?.ran) {
+    console.log(`
+${pc.bold("Test coverage:")}`);
+    if (testCoverageResult.success) {
+      console.log(`- ${pc.green("\u2713")} Coverage data generated successfully`);
+    } else {
+      console.log(`- ${pc.yellow("\u26A0")} Tests ran with errors`);
+      if (testCoverageResult.error) {
+        console.log(pc.dim(`  ${testCoverageResult.error.split("\n")[0]}`));
+      }
+    }
+  }
+  if (failedDeps.length > 0 || failedActions.length > 0) {
+    console.log(`
+${pc.bold(pc.red("Failures:"))}`);
+  }
+  if (failedDeps.length > 0) {
+    console.log(`
+${pc.bold("Dependency installs failed:")}`);
+    for (const dep of failedDeps) {
+      const pkgs = dep.install.packages.join(", ");
+      console.log(
+        `- ${pc.red("\u2717")} ${dep.install.packageManager} in ${dep.install.packagePath} ${pc.dim(`\u2190 ${pkgs}`)}`
+      );
+      if (dep.error) console.log(pc.dim(dep.error.split("\n").slice(0, 30).join("\n")));
+    }
+  }
+  if (failedActions.length > 0) {
+    console.log(`
+${pc.bold("Actions failed:")}`);
+    for (const a of failedActions) {
+      const action = a.action;
+      const type = String(action.type || "unknown");
+      const pathish = typeof action.path === "string" && action.path || typeof action.projectPath === "string" && action.projectPath || typeof action.packagePath === "string" && action.packagePath || "";
+      console.error(`- ${type}${pathish ? ` (${pathish})` : ""}`);
+      if (a.error) console.error(`  ${a.error}`);
+    }
+  }
+  console.log(
+    pc.dim(
+      `
+Summary: ${okActions.length} action(s) ok, ${failedActions.length} failed \xB7 ${okDeps.length} dep install(s) ok, ${failedDeps.length} failed`
+    )
+  );
+}
 function selectionsToUserChoices(selections, project, eslintRules, injectionPointConfig) {
   const items = [];
   const choices = { items };
@@ -5025,7 +4659,7 @@ async function installUI(options = {}, executeOptions = {}) {
             console.log("\nNo changes selected");
             process.exit(0);
           }
-          const { createPlan } = await import("./plan-SIXVCXCK.js");
+          const { createPlan } = await import("./plan-5WHKVACB.js");
           const plan = createPlan(project, choices, { force: options.force });
           if (hasUninstalls && uninstallSelections) {
             for (const selection of uninstallSelections) {
@@ -5041,17 +4675,28 @@ async function installUI(options = {}, executeOptions = {}) {
             ...executeOptions,
             projectPath: project.projectPath
           });
-          if (result.success) {
-            if (hasInstalls && hasUninstalls) {
-              console.log("\n\u2713 Changes applied successfully!");
-            } else if (hasUninstalls) {
-              console.log("\n\u2713 Uninstallation completed successfully!");
-            } else {
-              console.log("\n\u2713 Installation completed successfully!");
+          let testCoverageResult;
+          if (result.success && eslintRules?.some((r) => r.rule.id === "require-test-coverage")) {
+            const eslintTargetPaths = choices.eslint?.packagePaths ?? [];
+            for (const targetPath of eslintTargetPaths) {
+              const coverageSetup = detectCoverageSetup(targetPath);
+              if (coverageSetup.hasVitest && coverageSetup.hasCoverageConfig) {
+                console.log(`
+${pc.blue("Running tests with coverage...")}`);
+                const pm = detectPackageManager(targetPath);
+                try {
+                  await runTestsWithCoverage(pm, targetPath);
+                  testCoverageResult = { ran: true, success: true };
+                  console.log(`${pc.green("\u2713")} Coverage data generated`);
+                } catch (error) {
+                  const errorMsg = error instanceof Error ? error.message : String(error);
+                  testCoverageResult = { ran: true, success: false, error: errorMsg };
+                  console.log(`${pc.yellow("\u26A0")} Tests completed with errors`);
+                }
+              }
             }
-          } else {
-            console.log("\n\u26A0 Operation completed with errors");
           }
+          printInstallReport(result, testCoverageResult);
           process.exit(result.success ? 0 : 1);
         },
         onError: (error) => {
@@ -5066,4 +4711,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-HTVB5HDB.js.map
+//# sourceMappingURL=install-ui-CCZ3XJDE.js.map