uilint 0.2.8 → 0.2.9

package/dist/install-ui-OEFHX4FG.js

@@ -0,0 +1,3331 @@
+#!/usr/bin/env node
+import {
+  detectNextAppRouter,
+  findNextAppRouterProjects
+} from "./chunk-RHTG6DUD.js";
+import {
+  GENSTYLEGUIDE_COMMAND_MD,
+  loadSkill
+} from "./chunk-2RNDQVEK.js";
+
+// src/commands/install-ui.tsx
+import { render } from "ink";
+
+// src/commands/install/components/InstallApp.tsx
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { Box as Box3, Text as Text4, useApp as useApp2 } from "ink";
+
+// src/commands/install/components/Spinner.tsx
+import { useState, useEffect } from "react";
+import { Text } from "ink";
+import { jsx } from "react/jsx-runtime";
+var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner() {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prevFrame) => (prevFrame + 1) % frames.length);
+    }, 80);
+    return () => {
+      clearInterval(timer);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(Text, { color: "cyan", children: frames[frame] });
+}
+
+// src/commands/install/components/MultiSelect.tsx
+import { useState as useState2, useCallback } from "react";
+import { Box, Text as Text2, useInput, useApp } from "ink";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function StatusIndicator({ status, isSelected }) {
+  if (status === "installed") {
+    return /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" });
+  }
+  if (isSelected || status === "selected") {
+    return /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u25C9" });
+  }
+  if (status === "partial") {
+    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u25D0" });
+  }
+  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u25CB" });
+}
+function StatusLabel({ status }) {
+  if (status === "installed") {
+    return /* @__PURE__ */ jsx2(Text2, { color: "green", dimColor: true, children: "installed" });
+  }
+  if (status === "partial") {
+    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", dimColor: true, children: "partial" });
+  }
+  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "-" });
+}
+function ConfigSelector({
+  items,
+  onSubmit,
+  onCancel
+}) {
+  const { exit } = useApp();
+  const [cursor, setCursor] = useState2(0);
+  const [selected, setSelected] = useState2(() => {
+    return new Set(
+      items.filter((item) => item.status !== "installed" && !item.disabled).map((item) => item.id)
+    );
+  });
+  const categories = Array.from(new Set(items.map((item) => item.category)));
+  const itemsByCategory = /* @__PURE__ */ new Map();
+  for (const cat of categories) {
+    itemsByCategory.set(cat, items.filter((item) => item.category === cat));
+  }
+  const flatItems = items;
+  const handleToggle = useCallback(() => {
+    const item = flatItems[cursor];
+    if (!item || item.disabled || item.status === "installed") return;
+    setSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(item.id)) {
+        next.delete(item.id);
+      } else {
+        next.add(item.id);
+      }
+      return next;
+    });
+  }, [cursor, flatItems]);
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : flatItems.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < flatItems.length - 1 ? prev + 1 : 0);
+    } else if (input === " ") {
+      handleToggle();
+    } else if (key.return) {
+      onSubmit(Array.from(selected));
+    } else if (input === "q" || key.escape) {
+      onCancel?.();
+      exit();
+    } else if (input === "a") {
+      setSelected(
+        new Set(
+          items.filter((item) => item.status !== "installed" && !item.disabled).map((item) => item.id)
+        )
+      );
+    } else if (input === "n") {
+      setSelected(/* @__PURE__ */ new Set());
+    }
+  });
+  let globalIndex = 0;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    categories.map((category) => {
+      const categoryItems = itemsByCategory.get(category) || [];
+      const categoryIcon = categoryItems[0]?.categoryIcon || "\u2022";
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx2(Box, { children: /* @__PURE__ */ jsxs(Text2, { bold: true, color: "white", children: [
+          categoryIcon,
+          " ",
+          category
+        ] }) }),
+        categoryItems.map((item) => {
+          const itemIndex = globalIndex++;
+          const isCursor = itemIndex === cursor;
+          const isItemSelected = selected.has(item.id);
+          const isDisabled = item.disabled || item.status === "installed";
+          return /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx2(Text2, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+            /* @__PURE__ */ jsx2(Box, { width: 2, children: /* @__PURE__ */ jsx2(StatusIndicator, { status: item.status, isSelected: isItemSelected }) }),
+            /* @__PURE__ */ jsx2(Box, { width: 28, children: /* @__PURE__ */ jsx2(
+              Text2,
+              {
+                color: isDisabled ? void 0 : isCursor ? "cyan" : void 0,
+                dimColor: isDisabled,
+                children: item.label
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(Box, { width: 20, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: item.hint || "" }) }),
+            /* @__PURE__ */ jsx2(StatusLabel, { status: item.status })
+          ] }, item.id);
+        })
+      ] }, category);
+    }),
+    /* @__PURE__ */ jsx2(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs(Text2, { dimColor: true, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2191\u2193" }),
+      " navigate",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "space" }),
+      " toggle",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "a" }),
+      " all",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "n" }),
+      " none",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "enter" }),
+      " apply",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "q" }),
+      " quit"
+    ] }) }),
+    /* @__PURE__ */ jsx2(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: selected.size }),
+      /* @__PURE__ */ jsxs(Text2, { dimColor: true, children: [
+        " item",
+        selected.size !== 1 ? "s" : "",
+        " selected"
+      ] })
+    ] }) })
+  ] });
+}
+
+// src/commands/install/components/ProgressList.tsx
+import { Box as Box2, Text as Text3, Static } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function CompletedTask({ task }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713 " }),
+    /* @__PURE__ */ jsx3(Text3, { children: task.message })
+  ] });
+}
+function RunningTask({ task }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx3(Spinner, {}),
+      /* @__PURE__ */ jsxs2(Text3, { children: [
+        " ",
+        task.message
+      ] })
+    ] }),
+    task.detail && /* @__PURE__ */ jsx3(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+      "\u2514\u2500 ",
+      task.detail
+    ] }) })
+  ] });
+}
+function ErrorTask({ task }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "red", children: "\u2717 " }),
+      /* @__PURE__ */ jsx3(Text3, { color: "red", children: task.message })
+    ] }),
+    task.error && /* @__PURE__ */ jsx3(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text3, { color: "red", dimColor: true, children: [
+      "\u2514\u2500 ",
+      task.error
+    ] }) })
+  ] });
+}
+function PendingTask({ task }) {
+  return /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+    "\u25CB ",
+    task.message
+  ] }) });
+}
+function ProgressList({ tasks }) {
+  const completedTasks = tasks.filter((t) => t.status === "complete");
+  const runningTasks = tasks.filter((t) => t.status === "running");
+  const errorTasks = tasks.filter((t) => t.status === "error");
+  const pendingTasks = tasks.filter((t) => t.status === "pending");
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    completedTasks.length > 0 && /* @__PURE__ */ jsx3(Static, { items: completedTasks, children: (task) => /* @__PURE__ */ jsx3(CompletedTask, { task }, task.id) }),
+    runningTasks.map((task) => /* @__PURE__ */ jsx3(RunningTask, { task }, task.id)),
+    errorTasks.map((task) => /* @__PURE__ */ jsx3(ErrorTask, { task }, task.id)),
+    pendingTasks.map((task) => /* @__PURE__ */ jsx3(PendingTask, { task }, task.id))
+  ] });
+}
+function progressEventsToTasks(events) {
+  const tasks = [];
+  let taskIdCounter = 0;
+  for (const event of events) {
+    if (event.type === "start") {
+      tasks.push({
+        id: `task-${taskIdCounter++}`,
+        status: "running",
+        message: event.message,
+        detail: event.detail
+      });
+    } else if (event.type === "progress") {
+      const lastRunning = tasks.reverse().find((t) => t.status === "running");
+      tasks.reverse();
+      if (lastRunning) {
+        lastRunning.message = event.message;
+        lastRunning.detail = event.detail;
+      } else {
+        tasks.push({
+          id: `task-${taskIdCounter++}`,
+          status: "running",
+          message: event.message,
+          detail: event.detail
+        });
+      }
+    } else if (event.type === "complete") {
+      const lastRunning = tasks.reverse().find((t) => t.status === "running");
+      tasks.reverse();
+      if (lastRunning) {
+        lastRunning.status = "complete";
+        lastRunning.detail = void 0;
+      }
+    } else if (event.type === "error") {
+      const lastRunning = tasks.reverse().find((t) => t.status === "running");
+      tasks.reverse();
+      if (lastRunning) {
+        lastRunning.status = "error";
+        lastRunning.error = event.error;
+      } else {
+        tasks.push({
+          id: `task-${taskIdCounter++}`,
+          status: "error",
+          message: event.message,
+          error: event.error
+        });
+      }
+    }
+  }
+  return tasks;
+}
+
+// src/commands/install/installers/registry.ts
+var installers = [];
+function registerInstaller(installer) {
+  if (installers.some((i) => i.id === installer.id)) {
+    console.warn(`Installer "${installer.id}" is already registered`);
+    return;
+  }
+  installers.push(installer);
+}
+function getAllInstallers() {
+  return installers;
+}
+
+// src/commands/install/components/InstallApp.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function buildConfigItems(project, selections) {
+  const items = [];
+  for (const selection of selections) {
+    const { installer, targets } = selection;
+    const categoryMap = {
+      genstyleguide: { name: "Commands", icon: "\u{1F4DD}" },
+      skill: { name: "Agent Skills", icon: "\u26A1" },
+      next: { name: "UI Overlay", icon: "\u{1F537}" },
+      vite: { name: "UI Overlay", icon: "\u26A1" },
+      eslint: { name: "ESLint Plugin", icon: "\u{1F50D}" }
+    };
+    const category = categoryMap[installer.id] || { name: "Other", icon: "\u2022" };
+    for (const target of targets) {
+      items.push({
+        id: `${installer.id}:${target.id}`,
+        label: target.label,
+        hint: target.hint,
+        status: target.isInstalled ? "installed" : "not_installed",
+        category: category.name,
+        categoryIcon: category.icon
+      });
+    }
+  }
+  return items;
+}
+function Header({ subtitle }) {
+  return /* @__PURE__ */ jsx4(Box3, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "\u25C6 UILint" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " v0.5.0" }),
+    subtitle && /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+      " \xB7 ",
+      subtitle
+    ] })
+  ] }) });
+}
+function ProjectContext({ project }) {
+  const parts = [];
+  parts.push(project.packageManager);
+  if (project.nextApps.length > 0) {
+    parts.push(`${project.nextApps.length} Next.js app${project.nextApps.length > 1 ? "s" : ""}`);
+  }
+  if (project.viteApps.length > 0) {
+    parts.push(`${project.viteApps.length} Vite app${project.viteApps.length > 1 ? "s" : ""}`);
+  }
+  const eslintCount = project.packages.filter((p) => p.eslintConfigPath).length;
+  if (eslintCount > 0) {
+    parts.push(`${eslintCount} ESLint config${eslintCount > 1 ? "s" : ""}`);
+  }
+  return /* @__PURE__ */ jsx4(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+    "Detected: ",
+    parts.join(" \xB7 ")
+  ] }) });
+}
+function InstallApp({
+  projectPromise,
+  onComplete,
+  onError
+}) {
+  const { exit } = useApp2();
+  const [state, setState] = useState3("scanning");
+  const [project, setProject] = useState3(null);
+  const [selections, setSelections] = useState3([]);
+  const [configItems, setConfigItems] = useState3([]);
+  const [progressEvents] = useState3([]);
+  const [error, setError] = useState3(null);
+  useEffect2(() => {
+    if (state !== "scanning") return;
+    projectPromise.then((proj) => {
+      setProject(proj);
+      const installers2 = getAllInstallers();
+      const initialSelections = installers2.filter((installer) => installer.isApplicable(proj)).map((installer) => {
+        const targets = installer.getTargets(proj);
+        const nonInstalledTargets = targets.filter((t) => !t.isInstalled);
+        return {
+          installer,
+          targets,
+          selected: nonInstalledTargets.length > 0
+        };
+      });
+      setSelections(initialSelections);
+      const items = buildConfigItems(proj, initialSelections);
+      setConfigItems(items);
+      setState("configuring");
+    }).catch((err) => {
+      setError(err);
+      setState("error");
+      onError?.(err);
+    });
+  }, [state, projectPromise, onError]);
+  const handleConfigSubmit = (selectedIds) => {
+    const selectedSet = new Set(selectedIds);
+    const updatedSelections = selections.map((sel) => {
+      const selectedTargets = sel.targets.filter(
+        (t) => selectedSet.has(`${sel.installer.id}:${t.id}`)
+      );
+      return {
+        ...sel,
+        targets: selectedTargets,
+        selected: selectedTargets.length > 0
+      };
+    });
+    setSelections(updatedSelections);
+    onComplete(updatedSelections);
+  };
+  const handleCancel = () => {
+    exit();
+  };
+  if (state === "scanning") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Header, { subtitle: "Install" }),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx4(Spinner, {}),
+        /* @__PURE__ */ jsx4(Text4, { children: " Scanning project..." })
+      ] })
+    ] });
+  }
+  if (state === "error") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Header, {}),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "red", children: "\u2717 " }),
+        /* @__PURE__ */ jsx4(Text4, { color: "red", children: error?.message || "An unknown error occurred" })
+      ] })
+    ] });
+  }
+  if (state === "configuring" && project && configItems.length > 0) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Header, { subtitle: "Configuration" }),
+      /* @__PURE__ */ jsx4(ProjectContext, { project }),
+      /* @__PURE__ */ jsx4(
+        ConfigSelector,
+        {
+          items: configItems,
+          onSubmit: handleConfigSubmit,
+          onCancel: handleCancel
+        }
+      )
+    ] });
+  }
+  if (state === "executing") {
+    const tasks = progressEventsToTasks(progressEvents);
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Header, { subtitle: "Installing" }),
+      /* @__PURE__ */ jsx4(ProgressList, { tasks })
+    ] });
+  }
+  if (state === "complete") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx4(Header, {}),
+      /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u2713 " }),
+        /* @__PURE__ */ jsx4(Text4, { children: "Configuration applied successfully!" })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Header, {}),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Loading..." })
+  ] });
+}
+
+// src/commands/install/analyze.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { findWorkspaceRoot as findWorkspaceRoot2 } from "uilint-core/node";
+
+// src/utils/vite-detect.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var VITE_CONFIG_EXTS = [".ts", ".mjs", ".js", ".cjs"];
+function findViteConfigFile(projectPath) {
+  for (const ext of VITE_CONFIG_EXTS) {
+    const rel = `vite.config${ext}`;
+    if (existsSync(join(projectPath, rel))) return rel;
+  }
+  return null;
+}
+function looksLikeReactPackage(projectPath) {
+  try {
+    const pkgPath = join(projectPath, "package.json");
+    if (!existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    return "react" in deps || "react-dom" in deps;
+  } catch {
+    return false;
+  }
+}
+function fileExists(projectPath, relPath) {
+  return existsSync(join(projectPath, relPath));
+}
+function detectViteReact(projectPath) {
+  const configFile = findViteConfigFile(projectPath);
+  if (!configFile) return null;
+  if (!looksLikeReactPackage(projectPath)) return null;
+  const entryRoot = "src";
+  const candidates = [];
+  const entryCandidates = [
+    join(entryRoot, "main.tsx"),
+    join(entryRoot, "main.jsx"),
+    join(entryRoot, "main.ts"),
+    join(entryRoot, "main.js")
+  ];
+  for (const rel of entryCandidates) {
+    if (fileExists(projectPath, rel)) candidates.push(rel);
+  }
+  const fallbackCandidates = [
+    join(entryRoot, "App.tsx"),
+    join(entryRoot, "App.jsx")
+  ];
+  for (const rel of fallbackCandidates) {
+    if (!candidates.includes(rel) && fileExists(projectPath, rel)) {
+      candidates.push(rel);
+    }
+  }
+  return {
+    configFile,
+    configFileAbs: join(projectPath, configFile),
+    entryRoot,
+    candidates
+  };
+}
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".vercel",
+  ".cursor",
+  "coverage",
+  ".uilint"
+]);
+function findViteReactProjects(rootDir, options) {
+  const maxDepth = options?.maxDepth ?? 4;
+  const ignoreDirs = options?.ignoreDirs ?? DEFAULT_IGNORE_DIRS;
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    if (visited.has(dir)) return;
+    visited.add(dir);
+    const detection = detectViteReact(dir);
+    if (detection) {
+      results.push({ projectPath: dir, detection });
+      return;
+    }
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true }).map((d) => ({
+        name: d.name,
+        isDirectory: d.isDirectory()
+      }));
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory) continue;
+      if (ignoreDirs.has(ent.name)) continue;
+      if (ent.name.startsWith(".") && ent.name !== ".") continue;
+      walk(join(dir, ent.name), depth + 1);
+    }
+  }
+  walk(rootDir, 0);
+  return results;
+}
+
+// src/utils/package-detect.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, relative } from "path";
+var DEFAULT_IGNORE_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".vercel",
+  ".cursor",
+  "coverage",
+  ".uilint",
+  ".pnpm"
+]);
+var ESLINT_CONFIG_FILES = [
+  "eslint.config.js",
+  "eslint.config.ts",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.json",
+  ".eslintrc.yml",
+  ".eslintrc.yaml",
+  ".eslintrc"
+];
+var FRONTEND_INDICATORS = [
+  "react",
+  "react-dom",
+  "next",
+  "vue",
+  "svelte",
+  "@angular/core",
+  "solid-js",
+  "preact"
+];
+function isFrontendPackage(pkgJson) {
+  const deps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies
+  };
+  return FRONTEND_INDICATORS.some((pkg) => pkg in deps);
+}
+function isTypeScriptPackage(dir, pkgJson) {
+  if (existsSync2(join2(dir, "tsconfig.json"))) {
+    return true;
+  }
+  const deps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies
+  };
+  if ("typescript" in deps) {
+    return true;
+  }
+  for (const configFile of ESLINT_CONFIG_FILES) {
+    if (configFile.endsWith(".ts") && existsSync2(join2(dir, configFile))) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasEslintConfig(dir) {
+  for (const file of ESLINT_CONFIG_FILES) {
+    if (existsSync2(join2(dir, file))) {
+      return true;
+    }
+  }
+  try {
+    const pkgPath = join2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      if (pkg.eslintConfig) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function findPackages(rootDir, options) {
+  const maxDepth = options?.maxDepth ?? 5;
+  const ignoreDirs = options?.ignoreDirs ?? DEFAULT_IGNORE_DIRS2;
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  function processPackage(dir, isRoot) {
+    const pkgPath = join2(dir, "package.json");
+    if (!existsSync2(pkgPath)) return null;
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const name = pkg.name || relative(rootDir, dir) || ".";
+      return {
+        path: dir,
+        displayPath: relative(rootDir, dir) || ".",
+        name,
+        hasEslintConfig: hasEslintConfig(dir),
+        isFrontend: isFrontendPackage(pkg),
+        isRoot,
+        isTypeScript: isTypeScriptPackage(dir, pkg)
+      };
+    } catch {
+      return null;
+    }
+  }
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    if (visited.has(dir)) return;
+    visited.add(dir);
+    const pkg = processPackage(dir, depth === 0);
+    if (pkg) {
+      results.push(pkg);
+    }
+    let entries = [];
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true }).map((d) => ({
+        name: d.name,
+        isDirectory: d.isDirectory()
+      }));
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory) continue;
+      if (ignoreDirs.has(ent.name)) continue;
+      if (ent.name.startsWith(".")) continue;
+      walk(join2(dir, ent.name), depth + 1);
+    }
+  }
+  walk(rootDir, 0);
+  return results.sort((a, b) => {
+    if (a.isRoot && !b.isRoot) return -1;
+    if (!a.isRoot && b.isRoot) return 1;
+    if (a.isFrontend && !b.isFrontend) return -1;
+    if (!a.isFrontend && b.isFrontend) return 1;
+    return a.displayPath.localeCompare(b.displayPath);
+  });
+}
+
+// src/utils/package-manager.ts
+import { existsSync as existsSync3 } from "fs";
+import { spawn } from "child_process";
+import { dirname, join as join3 } from "path";
+function detectPackageManager(projectPath) {
+  let dir = projectPath;
+  for (; ; ) {
+    if (existsSync3(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync3(join3(dir, "pnpm-workspace.yaml"))) return "pnpm";
+    if (existsSync3(join3(dir, "yarn.lock"))) return "yarn";
+    if (existsSync3(join3(dir, "bun.lockb"))) return "bun";
+    if (existsSync3(join3(dir, "bun.lock"))) return "bun";
+    if (existsSync3(join3(dir, "package-lock.json"))) return "npm";
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "npm";
+}
+function spawnAsync(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else
+        reject(new Error(`${command} ${args.join(" ")} exited with ${code}`));
+    });
+  });
+}
+async function installDependencies(pm, projectPath, packages) {
+  if (!packages.length) return;
+  switch (pm) {
+    case "pnpm":
+      await spawnAsync("pnpm", ["add", ...packages], projectPath);
+      return;
+    case "yarn":
+      await spawnAsync("yarn", ["add", ...packages], projectPath);
+      return;
+    case "bun":
+      await spawnAsync("bun", ["add", ...packages], projectPath);
+      return;
+    case "npm":
+    default:
+      await spawnAsync("npm", ["install", "--save", ...packages], projectPath);
+      return;
+  }
+}
+
+// src/utils/eslint-config-inject.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join4, relative as relative2, dirname as dirname2 } from "path";
+import { parseExpression, parseModule, generateCode } from "magicast";
+import { findWorkspaceRoot } from "uilint-core/node";
+var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
+function findEslintConfigFile(projectPath) {
+  for (const ext of CONFIG_EXTENSIONS) {
+    const configPath = join4(projectPath, `eslint.config${ext}`);
+    if (existsSync4(configPath)) {
+      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 = relative2(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 = relative2(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 = parseModule(
+      `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) {
+  try {
+    const mod = parseModule(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
+    };
+  } 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 = readFileSync3(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;
+  let fileExtension = ".js";
+  if (rulesToApply.length > 0) {
+    const firstRulePath = join4(
+      rulesRoot,
+      ".uilint",
+      "rules",
+      `${rulesToApply[0].id}.ts`
+    );
+    if (existsSync4(firstRulePath)) {
+      fileExtension = ".ts";
+    }
+  }
+  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 = parseModule(
+        `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 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 nextApps = [];
+  const directDetection = detectNextAppRouter(projectPath);
+  if (directDetection) {
+    nextApps.push({ projectPath, detection: directDetection });
+  } else {
+    const matches = findNextAppRouterProjects(workspaceRoot, { maxDepth: 5 });
+    for (const match of matches) {
+      nextApps.push({
+        projectPath: match.projectPath,
+        detection: match.detection
+      });
+    }
+  }
+  const viteApps = [];
+  const directVite = detectViteReact(projectPath);
+  if (directVite) {
+    viteApps.push({ projectPath, detection: directVite });
+  } else {
+    const matches = findViteReactProjects(workspaceRoot, { maxDepth: 5 });
+    for (const match of matches) {
+      viteApps.push({
+        projectPath: match.projectPath,
+        detection: match.detection
+      });
+    }
+  }
+  const rawPackages = findPackages(workspaceRoot);
+  const packages = rawPackages.map((pkg) => {
+    const eslintConfigPath = findEslintConfigFile(pkg.path);
+    let eslintConfigFilename = null;
+    let hasRules = false;
+    let configuredRuleIds = [];
+    if (eslintConfigPath) {
+      eslintConfigFilename = getEslintConfigFilename(eslintConfigPath);
+      try {
+        const source = readFileSync4(eslintConfigPath, "utf-8");
+        const info = getUilintEslintConfigInfoFromSource(source);
+        hasRules = info.configuredRuleIds.size > 0;
+        configuredRuleIds = Array.from(info.configuredRuleIds);
+      } catch {
+      }
+    }
+    return {
+      ...pkg,
+      eslintConfigPath,
+      eslintConfigFilename,
+      hasUilintRules: hasRules,
+      configuredRuleIds
+    };
+  });
+  return {
+    projectPath,
+    workspaceRoot,
+    packageManager,
+    cursorDir: {
+      exists: cursorDirExists,
+      path: cursorDir
+    },
+    styleguide: {
+      exists: styleguideExists,
+      path: styleguidePath
+    },
+    commands: {
+      genstyleguide: genstyleguideExists
+    },
+    nextApps,
+    viteApps,
+    packages
+  };
+}
+
+// src/commands/install/execute.ts
+import {
+  existsSync as existsSync10,
+  mkdirSync,
+  writeFileSync as writeFileSync5,
+  readFileSync as readFileSync8,
+  unlinkSync,
+  chmodSync
+} from "fs";
+import { dirname as dirname3 } from "path";
+
+// src/utils/react-inject.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
+function getDefaultCandidates(projectPath, appRoot) {
+  const viteMainCandidates = [
+    join6(appRoot, "main.tsx"),
+    join6(appRoot, "main.jsx"),
+    join6(appRoot, "main.ts"),
+    join6(appRoot, "main.js")
+  ];
+  const existingViteMain = viteMainCandidates.filter(
+    (rel) => existsSync6(join6(projectPath, rel))
+  );
+  if (existingViteMain.length > 0) return existingViteMain;
+  const viteAppCandidates = [join6(appRoot, "App.tsx"), join6(appRoot, "App.jsx")];
+  const existingViteApp = viteAppCandidates.filter(
+    (rel) => existsSync6(join6(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")
+  ];
+  const existingLayouts = layoutCandidates.filter(
+    (rel) => existsSync6(join6(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)));
+}
+function isUseClientDirective(stmt) {
+  return stmt?.type === "ExpressionStatement" && stmt.expression?.type === "StringLiteral" && stmt.expression.value === "use client";
+}
+function findImportDeclaration(program, from) {
+  if (!program || program.type !== "Program") return null;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ImportDeclaration") continue;
+    if (stmt.source?.value === from) return stmt;
+  }
+  return null;
+}
+function walkAst(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (node.type) visit(node);
+  for (const key of Object.keys(node)) {
+    const v = node[key];
+    if (!v) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) walkAst(item, visit);
+    } else if (typeof v === "object" && v.type) {
+      walkAst(v, visit);
+    }
+  }
+}
+function hasUILintDevtoolsJsx(program) {
+  let found = false;
+  walkAst(program, (node) => {
+    if (found) return;
+    if (node.type !== "JSXElement") return;
+    const name = node.openingElement?.name;
+    if (name?.type === "JSXIdentifier") {
+      if (name.name === "UILintProvider" || name.name === "uilint-devtools") {
+        found = true;
+      }
+    }
+  });
+  return found;
+}
+function addDevtoolsElementNextJs(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  if (hasUILintDevtoolsJsx(program)) return { changed: false };
+  const devtoolsMod = parseModule2(
+    "const __uilint_devtools = (<uilint-devtools />);"
+  );
+  const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+  if (!devtoolsJsx || devtoolsJsx.type !== "JSXElement")
+    return { changed: false };
+  let added = false;
+  walkAst(program, (node) => {
+    if (added) return;
+    if (node.type !== "JSXElement" && node.type !== "JSXFragment") return;
+    const children = node.children ?? [];
+    const childrenIndex = children.findIndex(
+      (child) => child?.type === "JSXExpressionContainer" && child.expression?.type === "Identifier" && child.expression.name === "children"
+    );
+    if (childrenIndex === -1) return;
+    children.splice(childrenIndex + 1, 0, devtoolsJsx);
+    added = true;
+  });
+  if (!added) {
+    throw new Error("Could not find `{children}` in target file to add devtools.");
+  }
+  return { changed: true };
+}
+function addDevtoolsElementVite(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  if (hasUILintDevtoolsJsx(program)) return { changed: false };
+  let added = false;
+  walkAst(program, (node) => {
+    if (added) return;
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "MemberExpression") return;
+    const prop = callee.property;
+    const isRender = prop?.type === "Identifier" && prop.name === "render" || prop?.type === "StringLiteral" && prop.value === "render" || prop?.type === "Literal" && prop.value === "render";
+    if (!isRender) return;
+    const arg0 = node.arguments?.[0];
+    if (!arg0) return;
+    if (arg0.type !== "JSXElement" && arg0.type !== "JSXFragment") return;
+    const devtoolsMod = parseModule2(
+      "const __uilint_devtools = (<uilint-devtools />);"
+    );
+    const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+    if (!devtoolsJsx) return;
+    const fragmentMod = parseModule2(
+      "const __fragment = (<></>);"
+    );
+    const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+    if (!fragmentJsx) return;
+    fragmentJsx.children = [arg0, devtoolsJsx];
+    node.arguments[0] = fragmentJsx;
+    added = true;
+  });
+  if (!added) {
+    throw new Error(
+      "Could not find a `.render(<...>)` call to add devtools. Expected a React entry like `createRoot(...).render(<App />)`."
+    );
+  }
+  return { changed: true };
+}
+function ensureSideEffectImport(program, from) {
+  if (!program || program.type !== "Program") return { changed: false };
+  const existing = findImportDeclaration(program, from);
+  if (existing) return { changed: false };
+  const importDecl = parseModule2(`import "${from}";`).$ast.body?.[0];
+  if (!importDecl) return { changed: false };
+  const body = program.body ?? [];
+  let insertAt = 0;
+  while (insertAt < body.length && isUseClientDirective(body[insertAt])) {
+    insertAt++;
+  }
+  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
+    insertAt++;
+  }
+  program.body.splice(insertAt, 0, importDecl);
+  return { changed: true };
+}
+async function installReactUILintOverlay(opts) {
+  const candidates = getDefaultCandidates(opts.projectPath, opts.appRoot);
+  if (!candidates.length) {
+    throw new Error(
+      `No suitable entry files found under ${opts.appRoot} (expected Next.js layout/page or Vite main/App).`
+    );
+  }
+  let chosen;
+  if (candidates.length > 1 && opts.confirmFileChoice) {
+    chosen = await opts.confirmFileChoice(candidates);
+  } else {
+    chosen = candidates[0];
+  }
+  const absTarget = join6(opts.projectPath, chosen);
+  const original = readFileSync5(absTarget, "utf-8");
+  let mod;
+  try {
+    mod = parseModule2(original);
+  } catch {
+    throw new Error(
+      `Unable to parse ${chosen} as JavaScript/TypeScript. Please update it manually.`
+    );
+  }
+  const program = mod.$ast;
+  const hasDevtoolsImport = !!findImportDeclaration(program, "uilint-react/devtools");
+  const hasOldImport = !!findImportDeclaration(program, "uilint-react");
+  const alreadyConfigured = (hasDevtoolsImport || hasOldImport) && hasUILintDevtoolsJsx(program);
+  let changed = false;
+  const importRes = ensureSideEffectImport(program, "uilint-react/devtools");
+  if (importRes.changed) changed = true;
+  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 modified = updated !== original;
+  if (modified) {
+    writeFileSync2(absTarget, updated, "utf-8");
+  }
+  return {
+    targetFile: chosen,
+    modified,
+    alreadyConfigured: alreadyConfigured && !modified
+  };
+}
+
+// src/utils/next-config-inject.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+import { parseModule as parseModule3, generateCode as generateCode3 } from "magicast";
+var CONFIG_EXTENSIONS2 = [".ts", ".mjs", ".js", ".cjs"];
+function findNextConfigFile(projectPath) {
+  for (const ext of CONFIG_EXTENSIONS2) {
+    const configPath = join7(projectPath, `next.config${ext}`);
+    if (existsSync7(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function getNextConfigFilename(configPath) {
+  const parts = configPath.split("/");
+  return parts[parts.length - 1] || "next.config.ts";
+}
+function isIdentifier2(node, name) {
+  return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
+}
+function isStringLiteral2(node) {
+  return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
+}
+function ensureEsmWithJsxLocImport(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  const existing = (program.body ?? []).find(
+    (s) => s?.type === "ImportDeclaration" && s.source?.value === "jsx-loc-plugin"
+  );
+  if (existing) {
+    const has = (existing.specifiers ?? []).some(
+      (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "withJsxLoc" || sp.imported?.value === "withJsxLoc")
+    );
+    if (has) return { changed: false };
+    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 = parseModule3('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0];
+  if (!importDecl) return { changed: false };
+  const body = program.body ?? [];
+  let insertAt = 0;
+  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
+    insertAt++;
+  }
+  program.body.splice(insertAt, 0, importDecl);
+  return { changed: true };
+}
+function ensureCjsWithJsxLocRequire(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  for (const stmt of program.body ?? []) {
+    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 (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");
+          });
+          if (has) return { changed: false };
+          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 };
+        }
+        return { changed: false };
+      }
+    }
+  }
+  const reqDecl = parseModule3('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0];
+  if (!reqDecl) return { changed: false };
+  program.body.unshift(reqDecl);
+  return { changed: true };
+}
+function wrapEsmExportDefault(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  const exportDecl = (program.body ?? []).find(
+    (s) => s?.type === "ExportDefaultDeclaration"
+  );
+  if (!exportDecl) return { changed: false };
+  const decl = exportDecl.declaration;
+  if (decl?.type === "CallExpression" && isIdentifier2(decl.callee, "withJsxLoc")) {
+    return { changed: false };
+  }
+  exportDecl.declaration = {
+    type: "CallExpression",
+    callee: { type: "Identifier", name: "withJsxLoc" },
+    arguments: [decl]
+  };
+  return { changed: true };
+}
+function wrapCjsModuleExports(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  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" && isIdentifier2(left.object, "module") && isIdentifier2(left.property, "exports");
+    if (!isModuleExports) continue;
+    if (right?.type === "CallExpression" && isIdentifier2(right.callee, "withJsxLoc")) {
+      return { changed: false };
+    }
+    expr.right = {
+      type: "CallExpression",
+      callee: { type: "Identifier", name: "withJsxLoc" },
+      arguments: [right]
+    };
+    return { changed: true };
+  }
+  return { changed: false };
+}
+async function installJsxLocPlugin(opts) {
+  const configPath = findNextConfigFile(opts.projectPath);
+  if (!configPath) {
+    return { configFile: null, modified: false };
+  }
+  const configFilename = getNextConfigFilename(configPath);
+  const original = readFileSync6(configPath, "utf-8");
+  let mod;
+  try {
+    mod = parseModule3(original);
+  } catch {
+    return { configFile: configFilename, modified: false };
+  }
+  const program = mod.$ast;
+  const isCjs = configPath.endsWith(".cjs");
+  let changed = false;
+  if (isCjs) {
+    const reqRes = ensureCjsWithJsxLocRequire(program);
+    if (reqRes.changed) changed = true;
+    const wrapRes = wrapCjsModuleExports(program);
+    if (wrapRes.changed) changed = true;
+  } else {
+    const impRes = ensureEsmWithJsxLocImport(program);
+    if (impRes.changed) changed = true;
+    const wrapRes = wrapEsmExportDefault(program);
+    if (wrapRes.changed) changed = true;
+  }
+  const updated = changed ? generateCode3(mod).code : original;
+  if (updated !== original) {
+    writeFileSync3(configPath, updated, "utf-8");
+    return { configFile: configFilename, modified: true };
+  }
+  return { configFile: configFilename, modified: false };
+}
+
+// src/utils/vite-config-inject.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+import { parseModule as parseModule4, generateCode as generateCode4 } from "magicast";
+var CONFIG_EXTENSIONS3 = [".ts", ".mjs", ".js", ".cjs"];
+function findViteConfigFile2(projectPath) {
+  for (const ext of CONFIG_EXTENSIONS3) {
+    const configPath = join8(projectPath, `vite.config${ext}`);
+    if (existsSync8(configPath)) return configPath;
+  }
+  return null;
+}
+function getViteConfigFilename(configPath) {
+  const parts = configPath.split("/");
+  return parts[parts.length - 1] || "vite.config.ts";
+}
+function isIdentifier3(node, name) {
+  return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
+}
+function isStringLiteral3(node) {
+  return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
+}
+function unwrapExpression(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 findExportedConfigObjectExpression(mod) {
+  const program = mod?.$ast;
+  if (!program || program.type !== "Program") return null;
+  for (const stmt of program.body ?? []) {
+    if (!stmt || stmt.type !== "ExportDefaultDeclaration") continue;
+    const decl = unwrapExpression(stmt.declaration);
+    if (!decl) break;
+    if (decl.type === "ObjectExpression") {
+      return { kind: "esm", objExpr: decl, program };
+    }
+    if (decl.type === "CallExpression" && isIdentifier3(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ObjectExpression") {
+      return {
+        kind: "esm",
+        objExpr: unwrapExpression(decl.arguments?.[0]),
+        program
+      };
+    }
+    break;
+  }
+  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 = unwrapExpression(expr.right);
+    const isModuleExports = left?.type === "MemberExpression" && isIdentifier3(left.object, "module") && isIdentifier3(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") {
+      return {
+        kind: "cjs",
+        objExpr: unwrapExpression(right.arguments?.[0]),
+        program
+      };
+    }
+  }
+  return null;
+}
+function getObjectProperty(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") continue;
+    const key = prop.key;
+    const keyMatch = key?.type === "Identifier" && key.name === keyName || isStringLiteral3(key) && key.value === keyName;
+    if (keyMatch) return prop;
+  }
+  return null;
+}
+function ensureEsmJsxLocImport(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  const existing = (program.body ?? []).find(
+    (s) => s?.type === "ImportDeclaration" && s.source?.value === "jsx-loc-plugin/vite"
+  );
+  if (existing) {
+    const has = (existing.specifiers ?? []).some(
+      (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "jsxLoc" || sp.imported?.value === "jsxLoc")
+    );
+    if (has) return { changed: false };
+    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 = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
+  if (!importDecl) return { changed: false };
+  const body = program.body ?? [];
+  let insertAt = 0;
+  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
+    insertAt++;
+  }
+  program.body.splice(insertAt, 0, importDecl);
+  return { changed: true };
+}
+function ensureCjsJsxLocRequire(program) {
+  if (!program || program.type !== "Program") return { changed: false };
+  for (const stmt of program.body ?? []) {
+    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 (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");
+          });
+          if (has) return { changed: false };
+          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 };
+        }
+        return { changed: false };
+      }
+    }
+  }
+  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 };
+}
+function pluginsHasJsxLoc(arr) {
+  if (!arr || arr.type !== "ArrayExpression") return false;
+  for (const el of arr.elements ?? []) {
+    const e = unwrapExpression(el);
+    if (!e) continue;
+    if (e.type === "CallExpression" && isIdentifier3(e.callee, "jsxLoc")) return true;
+  }
+  return false;
+}
+function ensurePluginsContainsJsxLoc(configObj) {
+  const pluginsProp = getObjectProperty(configObj, "plugins");
+  if (!pluginsProp) {
+    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";
+    });
+    if (!prop) return { changed: false };
+    configObj.properties = [...configObj.properties ?? [], prop];
+    return { changed: true };
+  }
+  const value = unwrapExpression(pluginsProp.value);
+  if (!value) return { changed: false };
+  if (value.type === "ArrayExpression") {
+    if (pluginsHasJsxLoc(value)) return { changed: false };
+    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 = 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] };
+  return { changed: true };
+}
+async function installViteJsxLocPlugin(opts) {
+  const configPath = findViteConfigFile2(opts.projectPath);
+  if (!configPath) return { configFile: null, modified: false };
+  const configFilename = getViteConfigFilename(configPath);
+  const original = readFileSync7(configPath, "utf-8");
+  const isCjs = configPath.endsWith(".cjs");
+  let mod;
+  try {
+    mod = parseModule4(original);
+  } catch {
+    return { configFile: configFilename, modified: false };
+  }
+  const found = findExportedConfigObjectExpression(mod);
+  if (!found) return { configFile: configFilename, modified: false };
+  let changed = false;
+  if (isCjs) {
+    const reqRes = ensureCjsJsxLocRequire(found.program);
+    if (reqRes.changed) changed = true;
+  } else {
+    const impRes = ensureEsmJsxLocImport(found.program);
+    if (impRes.changed) changed = true;
+  }
+  const pluginsRes = ensurePluginsContainsJsxLoc(found.objExpr);
+  if (pluginsRes.changed) changed = true;
+  const updated = changed ? generateCode4(mod).code : original;
+  if (updated !== original) {
+    writeFileSync4(configPath, updated, "utf-8");
+    return { configFile: configFilename, modified: true };
+  }
+  return { configFile: configFilename, modified: false };
+}
+
+// src/utils/next-routes.ts
+import { existsSync as existsSync9 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join as join9 } from "path";
+var DEV_SOURCE_ROUTE_TS = `/**
+ * Dev-only API route for fetching source files
+ *
+ * This route allows the UILint overlay to fetch and display source code
+ * for components rendered on the page.
+ *
+ * Security:
+ * - Only available in development mode
+ * - Validates file path is within project root
+ * - Only allows specific file extensions
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, existsSync } from "fs";
+import { resolve, relative, dirname, extname, sep } from "path";
+import { fileURLToPath } from "url";
+
+export const runtime = "nodejs";
+
+// Allowed file extensions
+const ALLOWED_EXTENSIONS = new Set([".tsx", ".ts", ".jsx", ".js", ".css"]);
+
+/**
+ * Best-effort: resolve the Next.js project root (the dir that owns .next/) even in monorepos.
+ *
+ * Why: In monorepos, process.cwd() might be the workspace root (it also has package.json),
+ * which would incorrectly store/read files under the wrong directory.
+ */
+function findNextProjectRoot(): string {
+  // Prefer discovering via this route module's on-disk path.
+  // In Next, route code is executed from within ".next/server/...".
+  try {
+    const selfPath = fileURLToPath(import.meta.url);
+    const marker = sep + ".next" + sep;
+    const idx = selfPath.lastIndexOf(marker);
+    if (idx !== -1) {
+      return selfPath.slice(0, idx);
+    }
+  } catch {
+    // ignore
+  }
+
+  // Fallback: walk up from cwd looking for .next/
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(resolve(dir, ".next"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Final fallback: cwd
+  return process.cwd();
+}
+
+/**
+ * Validate that a path is within the allowed directory
+ */
+function isPathWithinRoot(filePath: string, root: string): boolean {
+  const resolved = resolve(filePath);
+  const resolvedRoot = resolve(root);
+  return resolved.startsWith(resolvedRoot + "/") || resolved === resolvedRoot;
+}
+
+/**
+ * Find workspace root by walking up looking for pnpm-workspace.yaml or .git
+ */
+function findWorkspaceRoot(startDir: string): string {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (
+      existsSync(resolve(dir, "pnpm-workspace.yaml")) ||
+      existsSync(resolve(dir, ".git"))
+    ) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+
+export async function GET(request: NextRequest) {
+  // Block in production
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "Not available in production" },
+      { status: 404 }
+    );
+  }
+
+  const { searchParams } = new URL(request.url);
+  const filePath = searchParams.get("path");
+
+  if (!filePath) {
+    return NextResponse.json(
+      { error: "Missing 'path' query parameter" },
+      { status: 400 }
+    );
+  }
+
+  // Validate extension
+  const ext = extname(filePath).toLowerCase();
+  if (!ALLOWED_EXTENSIONS.has(ext)) {
+    return NextResponse.json(
+      { error: \`File extension '\${ext}' not allowed\` },
+      { status: 403 }
+    );
+  }
+
+  // Find project root (prefer Next project root over workspace root)
+  const projectRoot = findNextProjectRoot();
+
+  // Resolve the file path
+  const resolvedPath = resolve(filePath);
+
+  // Security check: ensure path is within project root or workspace root
+  const workspaceRoot = findWorkspaceRoot(projectRoot);
+  const isWithinApp = isPathWithinRoot(resolvedPath, projectRoot);
+  const isWithinWorkspace = isPathWithinRoot(resolvedPath, workspaceRoot);
+
+  if (!isWithinApp && !isWithinWorkspace) {
+    return NextResponse.json(
+      { error: "Path outside project directory" },
+      { status: 403 }
+    );
+  }
+
+  // Check file exists
+  if (!existsSync(resolvedPath)) {
+    return NextResponse.json({ error: "File not found" }, { status: 404 });
+  }
+
+  try {
+    const content = readFileSync(resolvedPath, "utf-8");
+    const relativePath = relative(workspaceRoot, resolvedPath);
+
+    return NextResponse.json({
+      content,
+      relativePath,
+      projectRoot,
+      workspaceRoot,
+    });
+  } catch (error) {
+    console.error("[Dev Source API] Error reading file:", error);
+    return NextResponse.json({ error: "Failed to read file" }, { status: 500 });
+  }
+}
+`;
+var SCREENSHOT_ROUTE_TS = `/**
+ * Dev-only API route for saving and retrieving vision analysis screenshots
+ *
+ * This route allows the UILint overlay to:
+ * - POST: Save screenshots and element manifests for vision analysis
+ * - GET: Retrieve screenshots or list available screenshots
+ *
+ * Security:
+ * - Only available in development mode
+ * - Saves to .uilint/screenshots/ directory within project
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { resolve, join, dirname, basename, sep } from "path";
+import { fileURLToPath } from "url";
+
+export const runtime = "nodejs";
+
+// Maximum screenshot size (10MB)
+const MAX_SCREENSHOT_SIZE = 10 * 1024 * 1024;
+
+/**
+ * Best-effort: resolve the Next.js project root (the dir that owns .next/) even in monorepos.
+ */
+function findNextProjectRoot(): string {
+  try {
+    const selfPath = fileURLToPath(import.meta.url);
+    const marker = sep + ".next" + sep;
+    const idx = selfPath.lastIndexOf(marker);
+    if (idx !== -1) {
+      return selfPath.slice(0, idx);
+    }
+  } catch {
+    // ignore
+  }
+
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(resolve(dir, ".next"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return process.cwd();
+}
+
+/**
+ * Get the screenshots directory path, creating it if needed
+ */
+function getScreenshotsDir(projectRoot: string): string {
+  const screenshotsDir = join(projectRoot, ".uilint", "screenshots");
+  if (!existsSync(screenshotsDir)) {
+    mkdirSync(screenshotsDir, { recursive: true });
+  }
+  return screenshotsDir;
+}
+
+/**
+ * Validate filename to prevent path traversal
+ */
+function isValidFilename(filename: string): boolean {
+  // Only allow alphanumeric, hyphens, underscores, and dots
+  // Must end with .png, .jpeg, .jpg, or .json
+  const validPattern = /^[a-zA-Z0-9_-]+\\.(png|jpeg|jpg|json)$/;
+  return validPattern.test(filename) && !filename.includes("..");
+}
+
+/**
+ * POST: Save a screenshot and optionally its manifest
+ */
+export async function POST(request: NextRequest) {
+  // Block in production
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "Not available in production" },
+      { status: 404 }
+    );
+  }
+
+  try {
+    const body = await request.json();
+    const { filename, imageData, manifest, analysisResult } = body;
+
+    if (!filename) {
+      return NextResponse.json({ error: "Missing 'filename'" }, { status: 400 });
+    }
+
+    // Validate filename
+    if (!isValidFilename(filename)) {
+      return NextResponse.json(
+        { error: "Invalid filename format" },
+        { status: 400 }
+      );
+    }
+
+    // Allow "sidecar-only" updates (manifest/analysisResult) without re-sending image bytes.
+    const hasImageData = typeof imageData === "string" && imageData.length > 0;
+    const hasSidecar =
+      typeof manifest !== "undefined" || typeof analysisResult !== "undefined";
+
+    if (!hasImageData && !hasSidecar) {
+      return NextResponse.json(
+        { error: "Nothing to save (provide imageData and/or manifest/analysisResult)" },
+        { status: 400 }
+      );
+    }
+
+    // Check size (image only)
+    if (hasImageData && imageData.length > MAX_SCREENSHOT_SIZE) {
+      return NextResponse.json(
+        { error: "Screenshot too large (max 10MB)" },
+        { status: 413 }
+      );
+    }
+
+    const projectRoot = findNextProjectRoot();
+    const screenshotsDir = getScreenshotsDir(projectRoot);
+
+    const imagePath = join(screenshotsDir, filename);
+
+    // Save the image (base64 data URL) if provided
+    if (hasImageData) {
+      const base64Data = imageData.includes(",")
+        ? imageData.split(",")[1]
+        : imageData;
+      writeFileSync(imagePath, Buffer.from(base64Data, "base64"));
+    }
+
+    // Save manifest and analysis result as JSON sidecar
+    if (hasSidecar) {
+      const jsonFilename = filename.replace(/\\.(png|jpeg|jpg)$/, ".json");
+      const jsonPath = join(screenshotsDir, jsonFilename);
+
+      // If a sidecar already exists, merge updates (lets us POST analysisResult later without re-sending image).
+      let existing: any = null;
+      if (existsSync(jsonPath)) {
+        try {
+          existing = JSON.parse(readFileSync(jsonPath, "utf-8"));
+        } catch {
+          existing = null;
+        }
+      }
+
+      const routeFromAnalysis =
+        analysisResult && typeof analysisResult === "object"
+          ? (analysisResult as any).route
+          : undefined;
+      const issuesFromAnalysis =
+        analysisResult && typeof analysisResult === "object"
+          ? (analysisResult as any).issues
+          : undefined;
+
+      const jsonData = {
+        ...(existing && typeof existing === "object" ? existing : {}),
+        timestamp: Date.now(),
+        filename,
+        screenshotFile: filename,
+        route:
+          typeof routeFromAnalysis === "string"
+            ? routeFromAnalysis
+            : (existing as any)?.route ?? null,
+        issues:
+          Array.isArray(issuesFromAnalysis)
+            ? issuesFromAnalysis
+            : (existing as any)?.issues ?? null,
+        manifest: typeof manifest === "undefined" ? existing?.manifest ?? null : manifest,
+        analysisResult:
+          typeof analysisResult === "undefined"
+            ? existing?.analysisResult ?? null
+            : analysisResult,
+      };
+      writeFileSync(jsonPath, JSON.stringify(jsonData, null, 2));
+    }
+
+    return NextResponse.json({
+      success: true,
+      path: imagePath,
+      projectRoot,
+      screenshotsDir,
+    });
+  } catch (error) {
+    console.error("[Screenshot API] Error saving screenshot:", error);
+    return NextResponse.json(
+      { error: "Failed to save screenshot" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET: Retrieve a screenshot or list available screenshots
+ */
+export async function GET(request: NextRequest) {
+  // Block in production
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "Not available in production" },
+      { status: 404 }
+    );
+  }
+
+  const { searchParams } = new URL(request.url);
+  const filename = searchParams.get("filename");
+  const list = searchParams.get("list");
+
+  const projectRoot = findNextProjectRoot();
+  const screenshotsDir = getScreenshotsDir(projectRoot);
+
+  // List mode: return all screenshots
+  if (list === "true") {
+    try {
+      const files = readdirSync(screenshotsDir);
+      const screenshots = files
+        .filter((f) => /\\.(png|jpeg|jpg)$/.test(f))
+        .map((f) => {
+          const jsonFile = f.replace(/\\.(png|jpeg|jpg)$/, ".json");
+          const jsonPath = join(screenshotsDir, jsonFile);
+          let metadata = null;
+          if (existsSync(jsonPath)) {
+            try {
+              metadata = JSON.parse(readFileSync(jsonPath, "utf-8"));
+            } catch {
+              // Ignore parse errors
+            }
+          }
+          return {
+            filename: f,
+            metadata,
+          };
+        })
+        .sort((a, b) => {
+          // Sort by timestamp descending (newest first)
+          const aTime = a.metadata?.timestamp || 0;
+          const bTime = b.metadata?.timestamp || 0;
+          return bTime - aTime;
+        });
+
+      return NextResponse.json({ screenshots, projectRoot, screenshotsDir });
+    } catch (error) {
+      console.error("[Screenshot API] Error listing screenshots:", error);
+      return NextResponse.json(
+        { error: "Failed to list screenshots" },
+        { status: 500 }
+      );
+    }
+  }
+
+  // Retrieve mode: get specific screenshot
+  if (!filename) {
+    return NextResponse.json(
+      { error: "Missing 'filename' parameter" },
+      { status: 400 }
+    );
+  }
+
+  if (!isValidFilename(filename)) {
+    return NextResponse.json(
+      { error: "Invalid filename format" },
+      { status: 400 }
+    );
+  }
+
+  const filePath = join(screenshotsDir, filename);
+
+  if (!existsSync(filePath)) {
+    return NextResponse.json(
+      { error: "Screenshot not found" },
+      { status: 404 }
+    );
+  }
+
+  try {
+    const content = readFileSync(filePath);
+    
+    // Determine content type
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const contentType =
+      ext === "json"
+        ? "application/json"
+        : ext === "png"
+        ? "image/png"
+        : "image/jpeg";
+
+    if (ext === "json") {
+      return NextResponse.json(JSON.parse(content.toString()));
+    }
+
+    return new NextResponse(content, {
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "no-cache",
+      },
+    });
+  } catch (error) {
+    console.error("[Screenshot API] Error reading screenshot:", error);
+    return NextResponse.json(
+      { error: "Failed to read screenshot" },
+      { status: 500 }
+    );
+  }
+}
+`;
+async function writeRouteFile(absPath, relPath, content, opts) {
+  if (existsSync9(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 });
+  await writeRouteFile(
+    join9(baseAbs, "source", "route.ts"),
+    join9(baseRel, "source", "route.ts"),
+    DEV_SOURCE_ROUTE_TS,
+    opts
+  );
+  await mkdir(join9(baseAbs, "screenshots"), { recursive: true });
+  await writeRouteFile(
+    join9(baseAbs, "screenshots", "route.ts"),
+    join9(baseRel, "screenshots", "route.ts"),
+    SCREENSHOT_ROUTE_TS,
+    opts
+  );
+}
+
+// src/commands/install/execute.ts
+async function executeAction(action, options) {
+  const { dryRun = false } = options;
+  try {
+    switch (action.type) {
+      case "create_directory": {
+        if (dryRun) {
+          return {
+            action,
+            success: true,
+            wouldDo: `Create directory: ${action.path}`
+          };
+        }
+        if (!existsSync10(action.path)) {
+          mkdirSync(action.path, { recursive: true });
+        }
+        return { action, success: true };
+      }
+      case "create_file": {
+        if (dryRun) {
+          return {
+            action,
+            success: true,
+            wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
+          };
+        }
+        const dir = dirname3(action.path);
+        if (!existsSync10(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync5(action.path, action.content, "utf-8");
+        if (action.permissions) {
+          chmodSync(action.path, action.permissions);
+        }
+        return { action, success: true };
+      }
+      case "merge_json": {
+        if (dryRun) {
+          return {
+            action,
+            success: true,
+            wouldDo: `Merge JSON into: ${action.path}`
+          };
+        }
+        let existing = {};
+        if (existsSync10(action.path)) {
+          try {
+            existing = JSON.parse(readFileSync8(action.path, "utf-8"));
+          } catch {
+          }
+        }
+        const merged = deepMerge(existing, action.merge);
+        const dir = dirname3(action.path);
+        if (!existsSync10(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
+        return { action, success: true };
+      }
+      case "delete_file": {
+        if (dryRun) {
+          return {
+            action,
+            success: true,
+            wouldDo: `Delete file: ${action.path}`
+          };
+        }
+        if (existsSync10(action.path)) {
+          unlinkSync(action.path);
+        }
+        return { action, success: true };
+      }
+      case "append_to_file": {
+        if (dryRun) {
+          return {
+            action,
+            success: true,
+            wouldDo: `Append to file: ${action.path}`
+          };
+        }
+        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");
+        }
+        return { action, success: true };
+      }
+      case "inject_eslint": {
+        return await executeInjectEslint(action, options);
+      }
+      case "inject_react": {
+        return await executeInjectReact(action, options);
+      }
+      case "inject_next_config": {
+        return await executeInjectNextConfig(action, options);
+      }
+      case "inject_vite_config": {
+        return await executeInjectViteConfig(action, options);
+      }
+      case "install_next_routes": {
+        return await executeInstallNextRoutes(action, options);
+      }
+      default: {
+        const _exhaustive = action;
+        return {
+          action: _exhaustive,
+          success: false,
+          error: `Unknown action type`
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      action,
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function executeInjectEslint(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject ESLint rules into: ${action.configPath}`
+    };
+  }
+  const result = await installEslintPlugin({
+    projectPath: action.packagePath,
+    selectedRules: action.rules,
+    force: !action.hasExistingRules,
+    // Don't force if already has rules
+    // Auto-confirm for execute phase (choices were made during planning)
+    confirmAddMissingRules: async () => true
+  });
+  return {
+    action,
+    success: result.configFile !== null && result.configured,
+    error: result.configFile === null ? "No ESLint config found" : result.configured ? void 0 : result.error ?? "Failed to configure uilint in ESLint config"
+  };
+}
+async function executeInjectReact(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject <uilint-devtools /> into React app: ${action.projectPath}`
+    };
+  }
+  const result = await installReactUILintOverlay({
+    projectPath: action.projectPath,
+    appRoot: action.appRoot,
+    mode: action.mode,
+    force: false,
+    // Auto-select first choice for execute phase
+    confirmFileChoice: async (choices) => choices[0]
+  });
+  const success = result.modified || result.alreadyConfigured === true;
+  return {
+    action,
+    success,
+    error: success ? void 0 : "Failed to configure React overlay"
+  };
+}
+async function executeInjectViteConfig(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject jsx-loc-plugin into vite.config: ${action.projectPath}`
+    };
+  }
+  const result = await installViteJsxLocPlugin({
+    projectPath: action.projectPath,
+    force: false
+  });
+  return {
+    action,
+    success: result.modified || result.configFile !== null,
+    error: result.configFile === null ? "No vite.config found" : void 0
+  };
+}
+async function executeInjectNextConfig(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject jsx-loc-plugin into next.config: ${action.projectPath}`
+    };
+  }
+  const result = await installJsxLocPlugin({
+    projectPath: action.projectPath,
+    force: false
+  });
+  return {
+    action,
+    success: result.modified || result.configFile !== null,
+    error: result.configFile === null ? "No next.config found" : void 0
+  };
+}
+async function executeInstallNextRoutes(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Install Next.js API routes: ${action.projectPath}`
+    };
+  }
+  await installNextUILintRoutes({
+    projectPath: action.projectPath,
+    appRoot: action.appRoot,
+    force: false
+  });
+  return { action, success: true };
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function buildSummary(actionsPerformed, dependencyResults, items) {
+  const filesCreated = [];
+  const filesModified = [];
+  const filesDeleted = [];
+  const eslintTargets = [];
+  let nextApp;
+  let viteApp;
+  for (const result of actionsPerformed) {
+    if (!result.success) continue;
+    const { action } = result;
+    switch (action.type) {
+      case "create_file":
+        filesCreated.push(action.path);
+        break;
+      case "merge_json":
+      case "append_to_file":
+        filesModified.push(action.path);
+        break;
+      case "delete_file":
+        filesDeleted.push(action.path);
+        break;
+      case "inject_eslint":
+        filesModified.push(action.configPath);
+        eslintTargets.push({
+          displayName: action.packagePath,
+          configFile: action.configPath
+        });
+        break;
+      case "inject_react":
+        if (action.mode === "vite") {
+          viteApp = { entryRoot: action.appRoot };
+        } else {
+          nextApp = { appRoot: action.appRoot };
+        }
+        break;
+      case "install_next_routes":
+        nextApp = { appRoot: action.appRoot };
+        break;
+    }
+  }
+  const dependenciesInstalled = [];
+  for (const result of dependencyResults) {
+    if (result.success && !result.skipped) {
+      dependenciesInstalled.push({
+        packagePath: result.install.packagePath,
+        packages: result.install.packages
+      });
+    }
+  }
+  return {
+    installedItems: items,
+    filesCreated,
+    filesModified,
+    filesDeleted,
+    dependenciesInstalled,
+    eslintTargets,
+    nextApp,
+    viteApp
+  };
+}
+async function execute(plan, options = {}) {
+  const { dryRun = false, installDependencies: installDependencies2 = installDependencies } = options;
+  const actionsPerformed = [];
+  const dependencyResults = [];
+  for (const action of plan.actions) {
+    const result = await executeAction(action, options);
+    actionsPerformed.push(result);
+  }
+  for (const dep of plan.dependencies) {
+    if (dryRun) {
+      dependencyResults.push({
+        install: dep,
+        success: true,
+        skipped: true
+      });
+      continue;
+    }
+    try {
+      await installDependencies2(
+        dep.packageManager,
+        dep.packagePath,
+        dep.packages
+      );
+      dependencyResults.push({
+        install: dep,
+        success: true
+      });
+    } catch (error) {
+      dependencyResults.push({
+        install: dep,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const actionsFailed = actionsPerformed.filter((r) => !r.success);
+  const depsFailed = dependencyResults.filter((r) => !r.success);
+  const success = actionsFailed.length === 0 && depsFailed.length === 0;
+  const items = [];
+  for (const result of actionsPerformed) {
+    if (!result.success) continue;
+    const { action } = result;
+    if (action.type === "create_file") {
+      if (action.path.includes("genstyleguide.md")) items.push("genstyleguide");
+      if (action.path.includes("/skills/") && action.path.includes("SKILL.md")) items.push("skill");
+    }
+    if (action.type === "inject_eslint") items.push("eslint");
+    if (action.type === "install_next_routes") items.push("next");
+    if (action.type === "inject_react") {
+      items.push(action.mode === "vite" ? "vite" : "next");
+    }
+    if (action.type === "inject_vite_config") items.push("vite");
+  }
+  const uniqueItems = [...new Set(items)];
+  const summary = buildSummary(
+    actionsPerformed,
+    dependencyResults,
+    uniqueItems
+  );
+  return {
+    success,
+    actionsPerformed,
+    dependencyResults,
+    summary
+  };
+}
+
+// src/commands/install-ui.tsx
+import { ruleRegistry as ruleRegistry2 } from "uilint-eslint";
+
+// src/commands/install/installers/genstyleguide.ts
+import { join as join10 } from "path";
+var genstyleguideInstaller = {
+  id: "genstyleguide",
+  name: "/genstyleguide command",
+  description: "Cursor command to generate UI style guides",
+  icon: "\u{1F4DD}",
+  isApplicable(project) {
+    return true;
+  },
+  getTargets(project) {
+    const commandPath = join10(project.cursorDir.path, "commands", "genstyleguide.md");
+    const isInstalled = project.commands.genstyleguide;
+    return [
+      {
+        id: "genstyleguide-command",
+        label: ".cursor/commands/genstyleguide.md",
+        path: commandPath,
+        isInstalled
+      }
+    ];
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    const commandsDir = join10(project.cursorDir.path, "commands");
+    if (!project.cursorDir.exists) {
+      actions.push({
+        type: "create_directory",
+        path: project.cursorDir.path
+      });
+    }
+    actions.push({
+      type: "create_directory",
+      path: commandsDir
+    });
+    actions.push({
+      type: "create_file",
+      path: join10(commandsDir, "genstyleguide.md"),
+      content: GENSTYLEGUIDE_COMMAND_MD
+    });
+    return {
+      actions,
+      dependencies: []
+    };
+  },
+  async *execute(targets, config, project) {
+    yield {
+      type: "start",
+      message: "Installing /genstyleguide command"
+    };
+    yield {
+      type: "progress",
+      message: "Creating .cursor/commands directory"
+    };
+    yield {
+      type: "progress",
+      message: "Writing command file",
+      detail: "\u2192 .cursor/commands/genstyleguide.md"
+    };
+    yield {
+      type: "complete",
+      message: "Installed /genstyleguide command"
+    };
+  }
+};
+
+// src/commands/install/installers/skill.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+var skillInstaller = {
+  id: "skill",
+  name: "UI Consistency Agent skill",
+  description: "Claude Code skill for enforcing UI consistency",
+  icon: "\u26A1",
+  isApplicable(project) {
+    return true;
+  },
+  getTargets(project) {
+    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",
+        label: ".cursor/skills/ui-consistency-enforcer",
+        path: skillsDir,
+        isInstalled,
+        hint: "Agent skill for UI consistency checks"
+      }
+    ];
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    if (!project.cursorDir.exists) {
+      actions.push({
+        type: "create_directory",
+        path: project.cursorDir.path
+      });
+    }
+    const skillsDir = join11(project.cursorDir.path, "skills");
+    actions.push({
+      type: "create_directory",
+      path: skillsDir
+    });
+    try {
+      const skill = loadSkill("ui-consistency-enforcer");
+      const skillDir = join11(skillsDir, skill.name);
+      actions.push({
+        type: "create_directory",
+        path: skillDir
+      });
+      for (const file of skill.files) {
+        const filePath = join11(skillDir, file.relativePath);
+        const fileDir = join11(
+          skillDir,
+          file.relativePath.split("/").slice(0, -1).join("/")
+        );
+        if (fileDir !== skillDir && file.relativePath.includes("/")) {
+          actions.push({
+            type: "create_directory",
+            path: fileDir
+          });
+        }
+        actions.push({
+          type: "create_file",
+          path: filePath,
+          content: file.content
+        });
+      }
+    } catch (error) {
+      console.warn("Failed to load ui-consistency-enforcer skill:", error);
+    }
+    return {
+      actions,
+      dependencies: []
+    };
+  },
+  async *execute(targets, config, project) {
+    yield {
+      type: "start",
+      message: "Installing UI Consistency Agent skill"
+    };
+    yield {
+      type: "progress",
+      message: "Creating .cursor/skills directory"
+    };
+    try {
+      const skill = loadSkill("ui-consistency-enforcer");
+      for (const file of skill.files) {
+        yield {
+          type: "progress",
+          message: "Writing skill file",
+          detail: `\u2192 ${file.relativePath}`
+        };
+      }
+      yield {
+        type: "complete",
+        message: "Installed UI Consistency Agent skill"
+      };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: "Failed to install skill",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/commands/install/installers/eslint.ts
+import { join as join12 } from "path";
+import { ruleRegistry } from "uilint-eslint";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function toInstallSpecifier(pkgName) {
+  return pkgName;
+}
+var eslintInstaller = {
+  id: "eslint",
+  name: "ESLint plugin",
+  description: "Lint UI consistency with ESLint rules",
+  icon: "\u{1F50D}",
+  isApplicable(project) {
+    return project.packages.some((pkg) => pkg.eslintConfigPath !== null);
+  },
+  getTargets(project) {
+    return project.packages.filter((pkg) => pkg.eslintConfigPath !== null).map((pkg) => ({
+      id: `eslint-${pkg.name}`,
+      label: pkg.name,
+      path: pkg.path,
+      hint: pkg.eslintConfigFilename || "ESLint config detected",
+      isInstalled: pkg.hasUilintRules
+    }));
+  },
+  async configure(targets, project) {
+    const selectedRules = ruleRegistry;
+    return {
+      selectedRules
+    };
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    const dependencies = [];
+    const eslintConfig = config;
+    const { selectedRules } = eslintConfig;
+    for (const target of targets) {
+      const pkgInfo = project.packages.find((p) => p.path === target.path);
+      if (!pkgInfo || !pkgInfo.eslintConfigPath) continue;
+      const rulesDir = join12(target.path, ".uilint", "rules");
+      actions.push({
+        type: "create_directory",
+        path: rulesDir
+      });
+      dependencies.push({
+        packagePath: target.path,
+        packageManager: project.packageManager,
+        packages: [toInstallSpecifier("uilint-eslint"), "typescript-eslint"]
+      });
+      actions.push({
+        type: "inject_eslint",
+        packagePath: target.path,
+        configPath: pkgInfo.eslintConfigPath,
+        rules: selectedRules,
+        hasExistingRules: pkgInfo.hasUilintRules
+      });
+    }
+    const gitignorePath = join12(project.workspaceRoot, ".gitignore");
+    actions.push({
+      type: "append_to_file",
+      path: gitignorePath,
+      content: "\n# UILint cache\n.uilint/.cache\n",
+      ifNotContains: ".uilint/.cache"
+    });
+    return { actions, dependencies };
+  },
+  async *execute(targets, config, project) {
+    const eslintConfig = config;
+    yield {
+      type: "start",
+      message: "Installing ESLint plugin"
+    };
+    for (const target of targets) {
+      yield {
+        type: "progress",
+        message: `Configuring ESLint in ${target.label}`,
+        detail: "\u2192 Adding uilint-eslint to dependencies"
+      };
+      yield {
+        type: "progress",
+        message: `Injecting ${eslintConfig.selectedRules.length} rules`,
+        detail: `\u2192 ${target.hint}`
+      };
+    }
+    yield {
+      type: "complete",
+      message: `ESLint plugin installed in ${targets.length} package(s)`
+    };
+  }
+};
+
+// src/commands/install/installers/next-overlay.ts
+var nextOverlayInstaller = {
+  id: "next",
+  name: "Next.js overlay",
+  description: "Alt+Click UI inspector for Next.js App Router",
+  icon: "\u{1F537}",
+  isApplicable(project) {
+    return project.nextApps.length > 0;
+  },
+  getTargets(project) {
+    return project.nextApps.map((app) => ({
+      id: `next-${app.projectPath}`,
+      label: app.projectPath.split("/").pop() || app.projectPath,
+      path: app.projectPath,
+      hint: "App Router",
+      isInstalled: false
+      // TODO: Detect if already installed
+    }));
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    const dependencies = [];
+    if (targets.length === 0) return { actions, dependencies };
+    const target = targets[0];
+    const appInfo = project.nextApps.find((app) => app.projectPath === target.path);
+    if (!appInfo) return { actions, dependencies };
+    const { projectPath, detection } = appInfo;
+    actions.push({
+      type: "install_next_routes",
+      projectPath,
+      appRoot: detection.appRoot
+    });
+    dependencies.push({
+      packagePath: projectPath,
+      packageManager: project.packageManager,
+      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+    });
+    actions.push({
+      type: "inject_react",
+      projectPath,
+      appRoot: detection.appRoot,
+      mode: "next"
+    });
+    actions.push({
+      type: "inject_next_config",
+      projectPath
+    });
+    return { actions, dependencies };
+  },
+  async *execute(targets, config, project) {
+    if (targets.length === 0) return;
+    const target = targets[0];
+    yield {
+      type: "start",
+      message: "Installing Next.js overlay"
+    };
+    yield {
+      type: "progress",
+      message: `Installing in ${target.label}`,
+      detail: "\u2192 Adding API routes"
+    };
+    yield {
+      type: "progress",
+      message: "Installing dependencies",
+      detail: "\u2192 uilint-react, uilint-core, jsx-loc-plugin"
+    };
+    yield {
+      type: "progress",
+      message: "Injecting devtools component",
+      detail: "\u2192 <uilint-devtools /> in root layout"
+    };
+    yield {
+      type: "progress",
+      message: "Configuring jsx-loc-plugin",
+      detail: "\u2192 next.config.js"
+    };
+    yield {
+      type: "complete",
+      message: "Next.js overlay installed"
+    };
+  }
+};
+
+// src/commands/install/installers/vite-overlay.ts
+var viteOverlayInstaller = {
+  id: "vite",
+  name: "Vite overlay",
+  description: "Alt+Click UI inspector for Vite + React apps",
+  icon: "\u26A1",
+  isApplicable(project) {
+    return project.viteApps.length > 0;
+  },
+  getTargets(project) {
+    return project.viteApps.map((app) => ({
+      id: `vite-${app.projectPath}`,
+      label: app.projectPath.split("/").pop() || app.projectPath,
+      path: app.projectPath,
+      hint: "React + Vite",
+      isInstalled: false
+      // TODO: Detect if already installed
+    }));
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    const dependencies = [];
+    if (targets.length === 0) return { actions, dependencies };
+    const target = targets[0];
+    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"]
+    });
+    actions.push({
+      type: "inject_react",
+      projectPath,
+      appRoot: detection.entryRoot,
+      mode: "vite"
+    });
+    actions.push({
+      type: "inject_vite_config",
+      projectPath
+    });
+    return { actions, dependencies };
+  },
+  async *execute(targets, config, project) {
+    if (targets.length === 0) return;
+    const target = targets[0];
+    yield {
+      type: "start",
+      message: "Installing Vite overlay"
+    };
+    yield {
+      type: "progress",
+      message: `Installing in ${target.label}`,
+      detail: "\u2192 Adding dependencies"
+    };
+    yield {
+      type: "progress",
+      message: "Installing dependencies",
+      detail: "\u2192 uilint-react, uilint-core, jsx-loc-plugin"
+    };
+    yield {
+      type: "progress",
+      message: "Injecting devtools component",
+      detail: "\u2192 <uilint-devtools /> in entry file"
+    };
+    yield {
+      type: "progress",
+      message: "Configuring jsx-loc-plugin",
+      detail: "\u2192 vite.config.ts"
+    };
+    yield {
+      type: "complete",
+      message: "Vite overlay installed"
+    };
+  }
+};
+
+// src/commands/install/installers/index.ts
+registerInstaller(genstyleguideInstaller);
+registerInstaller(skillInstaller);
+registerInstaller(eslintInstaller);
+registerInstaller(nextOverlayInstaller);
+registerInstaller(viteOverlayInstaller);
+
+// src/commands/install-ui.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function selectionsToUserChoices(selections, project) {
+  const items = [];
+  const choices = { items };
+  for (const selection of selections) {
+    if (!selection.selected || selection.targets.length === 0) continue;
+    const { installer, targets } = selection;
+    if (installer.id === "genstyleguide") {
+      items.push("genstyleguide");
+    } else if (installer.id === "skill") {
+      items.push("skill");
+    } else if (installer.id === "eslint") {
+      items.push("eslint");
+      choices.eslint = {
+        packagePaths: targets.map((t) => t.path),
+        selectedRules: ruleRegistry2
+      };
+    } else if (installer.id === "next") {
+      items.push("next");
+      const target = targets[0];
+      const appInfo = project.nextApps.find(
+        (app) => app.projectPath === target?.path
+      );
+      if (appInfo) {
+        choices.next = {
+          projectPath: appInfo.projectPath,
+          detection: appInfo.detection
+        };
+      }
+    } else if (installer.id === "vite") {
+      items.push("vite");
+      const target = targets[0];
+      const appInfo = project.viteApps.find(
+        (app) => app.projectPath === target?.path
+      );
+      if (appInfo) {
+        choices.vite = {
+          projectPath: appInfo.projectPath,
+          detection: appInfo.detection
+        };
+      }
+    }
+  }
+  return choices;
+}
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function installUI(options = {}, executeOptions = {}) {
+  const projectPath = process.cwd();
+  if (!isInteractiveTerminal()) {
+    console.error("\n\u2717 Interactive mode requires a TTY terminal.");
+    console.error("Run uilint install in an interactive terminal.\n");
+    process.exit(1);
+  }
+  const projectPromise = analyze(projectPath);
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx5(
+      InstallApp,
+      {
+        projectPromise,
+        onComplete: async (selections) => {
+          const project = await projectPromise;
+          const choices = selectionsToUserChoices(selections, project);
+          if (choices.items.length === 0) {
+            console.log("\nNo items selected for installation");
+            process.exit(0);
+          }
+          const { createPlan } = await import("./plan-PX7FFJ25.js");
+          const plan = createPlan(project, choices, { force: options.force });
+          const result = await execute(plan, executeOptions);
+          if (result.success) {
+            console.log("\n\u2713 Installation completed successfully!");
+          } else {
+            console.log("\n\u26A0 Installation completed with errors");
+          }
+          process.exit(result.success ? 0 : 1);
+        },
+        onError: (error) => {
+          console.error("\n\u2717 Error:", error.message);
+          process.exit(1);
+        }
+      }
+    )
+  );
+  await waitUntilExit();
+}
+export {
+  installUI
+};
+//# sourceMappingURL=install-ui-OEFHX4FG.js.map