uilint 0.2.21 → 0.2.23

package/dist/{install-ui-2HMR6TZT.js → install-ui-TXV7A34M.js}

@@ -2,13 +2,18 @@
 import {
   confirm,
   detectNextAppRouter,
+  findEslintConfigFile,
   findNextAppRouterProjects,
+  getEslintConfigFilename,
+  getUilintEslintConfigInfoFromSource,
+  installEslintPlugin,
   log,
   multiselect,
   note,
   pc,
-  select
-} from "./chunk-FRNXXIEM.js";
+  select,
+  uninstallEslintPlugin
+} from "./chunk-PB5DLLVC.js";
 import {
   GENSTYLEGUIDE_COMMAND_MD,
   detectPackageManager,
@@ -137,8 +142,11 @@ function ProjectSelector({
 // src/commands/install/components/MultiSelect.tsx
 import { useState as useState3, useCallback } from "react";
 import { Box as Box2, Text as Text3, useInput as useInput2, useApp as useApp2 } from "ink";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function StatusIndicator({ status, isSelected }) {
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function StatusIndicator({ status, isSelected, isMarkedForUninstall }) {
+  if (isMarkedForUninstall) {
+    return /* @__PURE__ */ jsx3(Text3, { color: "red", children: "\u2717" });
+  }
   if (status === "installed") {
     return /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" });
   }
@@ -153,7 +161,10 @@ function StatusIndicator({ status, isSelected }) {
   }
   return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u25CB" });
 }
-function StatusLabel({ status }) {
+function StatusLabel({ status, isMarkedForUninstall }) {
+  if (isMarkedForUninstall) {
+    return /* @__PURE__ */ jsx3(Text3, { color: "red", dimColor: true, children: "uninstall" });
+  }
   if (status === "installed") {
     return /* @__PURE__ */ jsx3(Text3, { color: "green", dimColor: true, children: "installed" });
   }
@@ -177,6 +188,7 @@ function ConfigSelector({
       items.filter((item) => item.status !== "installed" && !item.disabled).map((item) => item.id)
     );
   });
+  const [markedForUninstall, setMarkedForUninstall] = useState3(/* @__PURE__ */ new Set());
   const categories = Array.from(new Set(items.map((item) => item.category)));
   const itemsByCategory = /* @__PURE__ */ new Map();
   for (const cat of categories) {
@@ -185,8 +197,19 @@ function ConfigSelector({
   const flatItems = items;
   const handleToggle = useCallback(() => {
     const item = flatItems[cursor];
-    const canToggle = item && !item.disabled && item.status !== "installed";
-    if (!canToggle) return;
+    if (!item || item.disabled) return;
+    if (item.status === "installed") {
+      setMarkedForUninstall((prev) => {
+        const next = new Set(prev);
+        if (next.has(item.id)) {
+          next.delete(item.id);
+        } else {
+          next.add(item.id);
+        }
+        return next;
+      });
+      return;
+    }
     setSelected((prev) => {
       const next = new Set(prev);
       if (next.has(item.id)) {
@@ -205,7 +228,7 @@ function ConfigSelector({
     } else if (input === " ") {
       handleToggle();
     } else if (key.return) {
-      onSubmit(Array.from(selected));
+      onSubmit(Array.from(selected), Array.from(markedForUninstall));
     } else if (input === "q" || key.escape) {
       onCancel?.();
       exit();
@@ -215,8 +238,10 @@ function ConfigSelector({
           items.filter((item) => item.status !== "installed" && !item.disabled).map((item) => item.id)
         )
       );
+      setMarkedForUninstall(/* @__PURE__ */ new Set());
     } else if (input === "n") {
       setSelected(/* @__PURE__ */ new Set());
+      setMarkedForUninstall(/* @__PURE__ */ new Set());
     }
   });
   let globalIndex = 0;
@@ -234,20 +259,21 @@ function ConfigSelector({
           const itemIndex = globalIndex++;
           const isCursor = itemIndex === cursor;
           const isItemSelected = selected.has(item.id);
-          const isDisabled = item.disabled || item.status === "installed";
+          const isItemMarkedForUninstall = markedForUninstall.has(item.id);
+          const isDisabled = item.disabled === true;
           return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 2, children: [
             /* @__PURE__ */ jsx3(Text3, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
-            /* @__PURE__ */ jsx3(Box2, { width: 2, children: /* @__PURE__ */ jsx3(StatusIndicator, { status: item.status, isSelected: isItemSelected }) }),
+            /* @__PURE__ */ jsx3(Box2, { width: 2, children: /* @__PURE__ */ jsx3(StatusIndicator, { status: item.status, isSelected: isItemSelected, isMarkedForUninstall: isItemMarkedForUninstall }) }),
             /* @__PURE__ */ jsx3(Box2, { width: 28, children: /* @__PURE__ */ jsx3(
               Text3,
               {
-                color: isDisabled ? void 0 : isCursor ? "cyan" : void 0,
-                dimColor: isDisabled,
+                color: isItemMarkedForUninstall ? "red" : isDisabled ? void 0 : isCursor ? "cyan" : void 0,
+                dimColor: isDisabled && !isItemMarkedForUninstall,
                 children: item.label
               }
             ) }),
             /* @__PURE__ */ jsx3(Box2, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: item.hint || "" }) }),
-            /* @__PURE__ */ jsx3(StatusLabel, { status: item.status })
+            /* @__PURE__ */ jsx3(StatusLabel, { status: item.status, isMarkedForUninstall: isItemMarkedForUninstall })
           ] }, item.id);
         })
       ] }, category);
@@ -273,10 +299,11 @@ function ConfigSelector({
     ] }) }),
     /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text3, { children: [
       /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: selected.size }),
-      /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
-        " item",
-        selected.size !== 1 ? "s" : "",
-        " selected"
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " to install" }),
+      markedForUninstall.size > 0 && /* @__PURE__ */ jsxs2(Fragment, { children: [
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ", " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "red", children: markedForUninstall.size }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " to uninstall" })
       ] })
     ] }) })
   ] });
@@ -819,7 +846,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) {
@@ -892,6 +919,32 @@ var nextOverlayInstaller = {
       type: "complete",
       message: "Next.js overlay installed"
     };
+  },
+  planUninstall(targets, project) {
+    const actions = [];
+    if (targets.length === 0) return { actions };
+    const target = targets[0];
+    const appInfo = project.nextApps.find(
+      (app) => app.projectPath === target.path
+    );
+    if (!appInfo) return { actions };
+    const { projectPath, detection } = appInfo;
+    actions.push({
+      type: "remove_react",
+      projectPath,
+      appRoot: detection.appRoot,
+      mode: "next"
+    });
+    actions.push({
+      type: "remove_next_config",
+      projectPath
+    });
+    actions.push({
+      type: "remove_next_routes",
+      projectPath,
+      appRoot: detection.appRoot
+    });
+    return { actions };
   }
 };
 
@@ -1029,6 +1082,7 @@ function InstallApp({
   const [selections, setSelections] = useState6([]);
   const [configItems, setConfigItems] = useState6([]);
   const [selectedFeatureIds, setSelectedFeatureIds] = useState6([]);
+  const [uninstallFeatureIds, setUninstallFeatureIds] = useState6([]);
   const [error, setError] = useState6(null);
   const [injectionPoints, setInjectionPoints] = useState6([]);
   const [selectedInjectionPoint, setSelectedInjectionPoint] = useState6(void 0);
@@ -1086,8 +1140,9 @@ function InstallApp({
       setPhase("select-project");
     }
   };
-  const handleFeatureSubmit = (selectedIds) => {
+  const handleFeatureSubmit = (selectedIds, uninstallIds) => {
     setSelectedFeatureIds(selectedIds);
+    setUninstallFeatureIds(uninstallIds);
     const nextSelected = selectedIds.some((id) => id.startsWith("next:"));
     if (nextSelected && project && selectedProject) {
       const appInfo = project.nextApps.find(
@@ -1143,6 +1198,7 @@ function InstallApp({
   };
   const finishInstallation = (selectedIds, eslintRules, injectionConfig) => {
     const selectedSet = new Set(selectedIds);
+    const uninstallSet = new Set(uninstallFeatureIds);
     const updatedSelections = selections.map((sel) => {
       const selectedTargets = sel.targets.filter(
         (t) => selectedSet.has(`${sel.installer.id}:${t.id}`)
@@ -1153,8 +1209,18 @@ function InstallApp({
         selected: selectedTargets.length > 0
       };
     });
+    const uninstallSelections = selections.map((sel) => {
+      const uninstallTargets = sel.targets.filter(
+        (t) => uninstallSet.has(`${sel.installer.id}:${t.id}`)
+      );
+      return {
+        ...sel,
+        targets: uninstallTargets,
+        selected: uninstallTargets.length > 0
+      };
+    }).filter((sel) => sel.selected);
     setSelections(updatedSelections);
-    onComplete(updatedSelections, eslintRules, injectionConfig);
+    onComplete(updatedSelections, eslintRules, injectionConfig, uninstallSelections.length > 0 ? uninstallSelections : void 0);
   };
   const handleCancel = () => {
     exit();
@@ -1248,9 +1314,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";
@@ -1493,585 +1559,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 void 0;
   }
-  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);
-  });
+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"]);
 }
-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 {
-    configFile: configFilename,
-    modified: false,
-    missingRuleIds: missingRules.map((r) => r.id),
-    configured: getUilintEslintConfigInfoFromSource(updated).configured
-  };
-}
-
-// 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)
       });
     }
   }
@@ -2084,7 +1628,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);
@@ -2122,49 +1666,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
+  chmodSync,
+  rmSync
 } from "fs";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname4 } 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";
@@ -2198,12 +1743,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;
@@ -2233,7 +1778,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;
@@ -2271,12 +1816,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;
@@ -2296,7 +1841,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;
@@ -2312,7 +1857,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;
@@ -2338,7 +1883,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];
@@ -2393,7 +1938,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;
@@ -2411,8 +1956,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;
 }
@@ -2423,32 +1968,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
   };
 }
@@ -2460,8 +2005,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,
@@ -2473,14 +2018,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.`
@@ -2503,10 +2048,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,
@@ -2527,11 +2072,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.`
@@ -2547,10 +2092,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,
@@ -2559,16 +2104,53 @@ async function installReactUILintOverlay(opts) {
     modifiedFiles: modified ? [absTarget] : []
   };
 }
+async function uninstallReactUILintOverlay(options) {
+  const { projectPath, appRoot, mode = "next" } = options;
+  const candidates = getDefaultCandidates(projectPath, appRoot);
+  const modifiedFiles = [];
+  for (const candidate of candidates) {
+    const absPath = join5(projectPath, candidate);
+    if (!existsSync5(absPath)) continue;
+    try {
+      const original = readFileSync5(absPath, "utf-8");
+      let updated = original.replace(
+        /^import\s+["']uilint-react\/devtools["'];?\s*$/gm,
+        ""
+      );
+      updated = updated.replace(
+        /^import\s+\{[^}]*UILintProvider[^}]*\}\s+from\s+["']uilint-react["'];?\s*$/gm,
+        ""
+      );
+      updated = updated.replace(/<uilint-devtools\s*\/>/g, "");
+      updated = updated.replace(/<uilint-devtools><\/uilint-devtools>/g, "");
+      updated = updated.replace(/<uilint-devtools\s*>\s*<\/uilint-devtools>/g, "");
+      updated = updated.replace(
+        /<UILintProvider[^>]*>([\s\S]*?)<\/UILintProvider>/g,
+        "$1"
+      );
+      updated = updated.replace(/\n{3,}/g, "\n\n");
+      if (updated !== original) {
+        writeFileSync(absPath, updated, "utf-8");
+        modifiedFiles.push(absPath);
+      }
+    } catch {
+    }
+  }
+  return {
+    success: true,
+    modifiedFiles
+  };
+}
 
 // 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;
     }
   }
@@ -2578,10 +2160,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) {
@@ -2594,12 +2176,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;
@@ -2615,14 +2197,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 };
@@ -2631,7 +2213,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 };
@@ -2643,7 +2225,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 = {
@@ -2661,9 +2243,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 = {
@@ -2681,10 +2263,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: [] };
   }
@@ -2702,23 +2284,69 @@ 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: [] };
 }
+async function uninstallJsxLocPlugin(options) {
+  const { projectPath } = options;
+  const configPath = findNextConfigFile(projectPath);
+  if (!configPath) {
+    return {
+      success: true,
+      modifiedFiles: []
+    };
+  }
+  try {
+    const original = readFileSync6(configPath, "utf-8");
+    let updated = original.replace(
+      /^import\s+\{[^}]*withJsxLoc[^}]*\}\s+from\s+["']jsx-loc-plugin\/next["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^const\s+\{[^}]*withJsxLoc[^}]*\}\s*=\s*require\s*\(\s*["']jsx-loc-plugin\/next["']\s*\)\s*;?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /export\s+default\s+withJsxLoc\s*\(\s*([\s\S]*?)\s*\)\s*;?/g,
+      "export default $1;"
+    );
+    updated = updated.replace(
+      /module\.exports\s*=\s*withJsxLoc\s*\(\s*([\s\S]*?)\s*\)\s*;?/g,
+      "module.exports = $1;"
+    );
+    updated = updated.replace(/\n{3,}/g, "\n\n");
+    if (updated !== original) {
+      writeFileSync2(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)
+    };
+  }
+}
 
 // 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;
 }
@@ -2726,10 +2354,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) {
@@ -2761,7 +2389,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]),
@@ -2776,12 +2404,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]),
@@ -2797,7 +2425,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;
@@ -2812,12 +2440,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;
@@ -2833,14 +2461,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 };
@@ -2849,7 +2477,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 };
@@ -2859,16 +2487,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];
@@ -2878,12 +2506,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] };
@@ -2893,11 +2521,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: [] };
   }
@@ -2913,18 +2541,61 @@ 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: [] };
 }
+async function uninstallViteJsxLocPlugin(options) {
+  const { projectPath } = options;
+  const configPath = findViteConfigFile2(projectPath);
+  if (!configPath) {
+    return {
+      success: true,
+      modifiedFiles: []
+    };
+  }
+  try {
+    const original = readFileSync7(configPath, "utf-8");
+    let updated = original.replace(
+      /^import\s+\{[^}]*jsxLoc[^}]*\}\s+from\s+["']jsx-loc-plugin\/vite["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^import\s+jsxLoc\s+from\s+["']jsx-loc-plugin\/vite["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^const\s+\{[^}]*jsxLoc[^}]*\}\s*=\s*require\s*\(\s*["']jsx-loc-plugin\/vite["']\s*\)\s*;?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(/jsxLoc\s*\(\s*\)\s*,?\s*/g, "");
+    updated = updated.replace(/\n{3,}/g, "\n\n");
+    if (updated !== original) {
+      writeFileSync3(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)
+    };
+  }
+}
 
 // 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
  *
@@ -3380,40 +3051,56 @@ 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
   );
 }
+async function uninstallNextUILintRoutes(options) {
+  const { projectPath, appRoot } = options;
+  const { rm } = await import("fs/promises");
+  const baseAbs = join8(projectPath, appRoot, "api", ".uilint");
+  try {
+    if (existsSync8(baseAbs)) {
+      await rm(baseAbs, { recursive: true, force: true });
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 
 // 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;
   }
@@ -3544,7 +3231,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 {
@@ -3565,7 +3252,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 };
@@ -3578,11 +3265,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);
         }
@@ -3597,18 +3284,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": {
@@ -3619,7 +3306,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 };
@@ -3632,12 +3319,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 };
       }
@@ -3656,6 +3343,25 @@ async function executeAction(action, options) {
       case "install_next_routes": {
         return await executeInstallNextRoutes(action, options);
       }
+      // Uninstall actions
+      case "remove_eslint": {
+        return await executeRemoveEslint(action, options);
+      }
+      case "remove_react": {
+        return await executeRemoveReact(action, options);
+      }
+      case "remove_next_config": {
+        return await executeRemoveNextConfig(action, options);
+      }
+      case "remove_vite_config": {
+        return await executeRemoveViteConfig(action, options);
+      }
+      case "remove_next_routes": {
+        return await executeRemoveNextRoutes(action, options);
+      }
+      case "remove_directory": {
+        return await executeRemoveDirectory(action, options);
+      }
       default: {
         const _exhaustive = action;
         return {
@@ -3781,6 +3487,117 @@ async function executeInstallNextRoutes(action, options) {
   });
   return { action, success: true };
 }
+async function executeRemoveEslint(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove uilint ESLint rules from: ${action.configPath}`
+    };
+  }
+  const result = await uninstallEslintPlugin({
+    projectPath: action.packagePath
+  });
+  return {
+    action,
+    success: result.success,
+    error: result.error,
+    modifiedFiles: result.modifiedFiles
+  };
+}
+async function executeRemoveReact(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove <uilint-devtools /> from: ${action.projectPath}`
+    };
+  }
+  const result = await uninstallReactUILintOverlay({
+    projectPath: action.projectPath,
+    appRoot: action.appRoot,
+    mode: action.mode
+  });
+  return {
+    action,
+    success: result.success,
+    error: result.error,
+    modifiedFiles: result.modifiedFiles
+  };
+}
+async function executeRemoveNextConfig(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove jsx-loc-plugin from next.config: ${action.projectPath}`
+    };
+  }
+  const result = await uninstallJsxLocPlugin({
+    projectPath: action.projectPath
+  });
+  return {
+    action,
+    success: result.success,
+    error: result.error,
+    modifiedFiles: result.modifiedFiles
+  };
+}
+async function executeRemoveViteConfig(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove jsx-loc-plugin from vite.config: ${action.projectPath}`
+    };
+  }
+  const result = await uninstallViteJsxLocPlugin({
+    projectPath: action.projectPath
+  });
+  return {
+    action,
+    success: result.success,
+    error: result.error,
+    modifiedFiles: result.modifiedFiles
+  };
+}
+async function executeRemoveNextRoutes(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove Next.js API routes: ${action.projectPath}`
+    };
+  }
+  const result = await uninstallNextUILintRoutes({
+    projectPath: action.projectPath,
+    appRoot: action.appRoot
+  });
+  return {
+    action,
+    success: result.success,
+    error: result.error
+  };
+}
+async function executeRemoveDirectory(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Remove directory: ${action.path}`
+    };
+  }
+  if (existsSync10(action.path)) {
+    rmSync(action.path, { recursive: true, force: true });
+  }
+  return { action, success: true };
+}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -4013,7 +3830,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",
@@ -4023,7 +3840,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 [
       {
@@ -4036,7 +3853,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",
@@ -4049,7 +3866,7 @@ var genstyleguideInstaller = {
     });
     actions.push({
       type: "create_file",
-      path: join11(commandsDir, "genstyleguide.md"),
+      path: join10(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
     return {
@@ -4075,12 +3892,21 @@ var genstyleguideInstaller = {
       type: "complete",
       message: "Installed /genstyleguide command"
     };
+  },
+  planUninstall(targets, project) {
+    const actions = [];
+    const commandPath = join10(project.cursorDir.path, "commands", "genstyleguide.md");
+    actions.push({
+      type: "delete_file",
+      path: commandPath
+    });
+    return { actions };
   }
 };
 
 // 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",
@@ -4090,9 +3916,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",
@@ -4111,21 +3937,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("/")
         );
@@ -4178,11 +4004,20 @@ var skillInstaller = {
         error: error instanceof Error ? error.message : String(error)
       };
     }
+  },
+  planUninstall(targets, project) {
+    const actions = [];
+    const skillDir = join11(project.cursorDir.path, "skills", "ui-consistency-enforcer");
+    actions.push({
+      type: "remove_directory",
+      path: skillDir
+    });
+    return { actions };
   }
 };
 
 // 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);
@@ -4358,7 +4193,7 @@ 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
@@ -4376,7 +4211,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,
@@ -4407,6 +4242,24 @@ var eslintInstaller = {
       type: "complete",
       message: `ESLint plugin installed in ${targets.length} package(s)`
     };
+  },
+  planUninstall(targets, project) {
+    const actions = [];
+    for (const target of targets) {
+      const pkgInfo = project.packages.find((p) => p.path === target.path);
+      if (!pkgInfo || !pkgInfo.eslintConfigPath) continue;
+      actions.push({
+        type: "remove_eslint",
+        packagePath: target.path,
+        configPath: pkgInfo.eslintConfigPath
+      });
+      const rulesDir = join12(target.path, ".uilint", "rules");
+      actions.push({
+        type: "remove_directory",
+        path: rulesDir
+      });
+    }
+    return { actions };
   }
 };
 
@@ -4425,8 +4278,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) {
@@ -4485,6 +4337,27 @@ var viteOverlayInstaller = {
       type: "complete",
       message: "Vite overlay installed"
     };
+  },
+  planUninstall(targets, project) {
+    const actions = [];
+    if (targets.length === 0) return { actions };
+    const target = targets[0];
+    const appInfo = project.viteApps.find(
+      (app) => app.projectPath === target.path
+    );
+    if (!appInfo) return { actions };
+    const { projectPath, detection } = appInfo;
+    actions.push({
+      type: "remove_react",
+      projectPath,
+      appRoot: detection.entryRoot,
+      mode: "vite"
+    });
+    actions.push({
+      type: "remove_vite_config",
+      projectPath
+    });
+    return { actions };
   }
 };
 
@@ -4566,23 +4439,41 @@ async function installUI(options = {}, executeOptions = {}) {
       InstallApp,
       {
         projectPromise,
-        onComplete: async (selections, eslintRules, injectionPointConfig) => {
+        onComplete: async (selections, eslintRules, injectionPointConfig, uninstallSelections) => {
           const project = await projectPromise;
           const choices = selectionsToUserChoices(selections, project, eslintRules, injectionPointConfig);
-          if (choices.items.length === 0) {
-            console.log("\nNo items selected for installation");
+          const hasInstalls = choices.items.length > 0;
+          const hasUninstalls = uninstallSelections && uninstallSelections.length > 0;
+          if (!hasInstalls && !hasUninstalls) {
+            console.log("\nNo changes selected");
             process.exit(0);
           }
           const { createPlan } = await import("./plan-SIXVCXCK.js");
           const plan = createPlan(project, choices, { force: options.force });
+          if (hasUninstalls && uninstallSelections) {
+            for (const selection of uninstallSelections) {
+              if (!selection.selected || selection.targets.length === 0) continue;
+              const { installer, targets } = selection;
+              if (installer.planUninstall) {
+                const uninstallPlan = installer.planUninstall(targets, project);
+                plan.actions = [...uninstallPlan.actions, ...plan.actions];
+              }
+            }
+          }
           const result = await execute(plan, {
             ...executeOptions,
             projectPath: project.projectPath
           });
           if (result.success) {
-            console.log("\n\u2713 Installation completed successfully!");
+            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!");
+            }
           } else {
-            console.log("\n\u26A0 Installation completed with errors");
+            console.log("\n\u26A0 Operation completed with errors");
           }
           process.exit(result.success ? 0 : 1);
         },
@@ -4598,4 +4489,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-2HMR6TZT.js.map
+//# sourceMappingURL=install-ui-TXV7A34M.js.map