uilint 0.2.9 → 0.2.11

package/dist/{install-ui-OEFHX4FG.js → install-ui-KI7YHOVZ.js}

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 import {
+  confirm,
   detectNextAppRouter,
-  findNextAppRouterProjects
-} from "./chunk-RHTG6DUD.js";
+  findNextAppRouterProjects,
+  log,
+  multiselect,
+  note,
+  pc,
+  select
+} from "./chunk-FRNXXIEM.js";
 import {
   GENSTYLEGUIDE_COMMAND_MD,
   loadSkill
@@ -12,8 +18,8 @@ import {
 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";
+import { useState as useState5, useEffect as useEffect2 } from "react";
+import { Box as Box4, Text as Text5, useApp as useApp4, useInput as useInput4 } from "ink";
 
 // src/commands/install/components/Spinner.tsx
 import { useState, useEffect } from "react";
@@ -33,39 +39,132 @@ function Spinner() {
   return /* @__PURE__ */ jsx(Text, { color: "cyan", children: frames[frame] });
 }
 
-// src/commands/install/components/MultiSelect.tsx
-import { useState as useState2, useCallback } from "react";
+// src/commands/install/components/ProjectSelector.tsx
+import { useState as useState2 } from "react";
 import { Box, Text as Text2, useInput, useApp } from "ink";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function getDetectedProjects(project) {
+  const projects = [];
+  for (const app of project.nextApps) {
+    const relativePath = app.projectPath.replace(project.workspaceRoot + "/", "");
+    projects.push({
+      id: `next:${app.projectPath}`,
+      name: relativePath || ".",
+      path: app.projectPath,
+      type: "nextjs",
+      hint: "Next.js App Router",
+      isConfigured: false
+      // TODO: detect if overlay is installed
+    });
+  }
+  for (const app of project.viteApps) {
+    const relativePath = app.projectPath.replace(project.workspaceRoot + "/", "");
+    projects.push({
+      id: `vite:${app.projectPath}`,
+      name: relativePath || ".",
+      path: app.projectPath,
+      type: "vite",
+      hint: "Vite + React",
+      isConfigured: false
+    });
+  }
+  return projects;
+}
+function FrameworkBadge({ type }) {
+  switch (type) {
+    case "nextjs":
+      return /* @__PURE__ */ jsx2(Text2, { color: "white", backgroundColor: "black", children: " Next.js " });
+    case "vite":
+      return /* @__PURE__ */ jsx2(Text2, { color: "black", backgroundColor: "yellow", children: " Vite " });
+    default:
+      return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Other" });
+  }
+}
+function ProjectSelector({
+  projects,
+  onSelect,
+  onCancel
+}) {
+  const { exit } = useApp();
+  const [cursor, setCursor] = useState2(0);
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : projects.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < projects.length - 1 ? prev + 1 : 0);
+    } else if (key.return) {
+      const selected = projects[cursor];
+      if (selected) {
+        onSelect(selected);
+      }
+    } else if (input === "q" || key.escape) {
+      onCancel?.();
+      exit();
+    }
+  });
+  if (projects.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "No projects detected." }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "UILint works with Next.js (App Router) and Vite + React projects." })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Select a project to configure:" }) }),
+    projects.map((project, index) => {
+      const isCursor = index === cursor;
+      return /* @__PURE__ */ jsxs(Box, { paddingLeft: 1, children: [
+        /* @__PURE__ */ jsx2(Text2, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+        /* @__PURE__ */ jsx2(Box, { width: 12, children: /* @__PURE__ */ jsx2(FrameworkBadge, { type: project.type }) }),
+        /* @__PURE__ */ jsx2(Box, { width: 30, children: /* @__PURE__ */ jsx2(Text2, { color: isCursor ? "cyan" : void 0, bold: isCursor, children: project.name }) }),
+        project.isConfigured && /* @__PURE__ */ jsx2(Text2, { color: "green", dimColor: true, children: "configured" })
+      ] }, project.id);
+    }),
+    /* @__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: "enter" }),
+      " select",
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "q" }),
+      " quit"
+    ] }) })
+  ] });
+}
+
+// src/commands/install/components/MultiSelect.tsx
+import { useState as useState3, useCallback } from "react";
+import { Box as Box2, Text as Text3, useInput as useInput2, useApp as useApp2 } from "ink";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function StatusIndicator({ status, isSelected }) {
   if (status === "installed") {
-    return /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" });
+    return /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" });
   }
   if (isSelected || status === "selected") {
-    return /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u25C9" });
+    return /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u25C9" });
   }
   if (status === "partial") {
-    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u25D0" });
+    return /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u25D0" });
   }
-  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u25CB" });
+  return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u25CB" });
 }
 function StatusLabel({ status }) {
   if (status === "installed") {
-    return /* @__PURE__ */ jsx2(Text2, { color: "green", dimColor: true, children: "installed" });
+    return /* @__PURE__ */ jsx3(Text3, { color: "green", dimColor: true, children: "installed" });
   }
   if (status === "partial") {
-    return /* @__PURE__ */ jsx2(Text2, { color: "yellow", dimColor: true, children: "partial" });
+    return /* @__PURE__ */ jsx3(Text3, { color: "yellow", dimColor: true, children: "partial" });
   }
-  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "-" });
+  return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "-" });
 }
 function ConfigSelector({
   items,
   onSubmit,
   onCancel
 }) {
-  const { exit } = useApp();
-  const [cursor, setCursor] = useState2(0);
-  const [selected, setSelected] = useState2(() => {
+  const { exit } = useApp2();
+  const [cursor, setCursor] = useState3(0);
+  const [selected, setSelected] = useState3(() => {
     return new Set(
       items.filter((item) => item.status !== "installed" && !item.disabled).map((item) => item.id)
     );
@@ -89,7 +188,7 @@ function ConfigSelector({
       return next;
     });
   }, [cursor, flatItems]);
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.upArrow) {
       setCursor((prev) => prev > 0 ? prev - 1 : flatItems.length - 1);
     } else if (key.downArrow) {
@@ -112,12 +211,12 @@ function ConfigSelector({
     }
   });
   let globalIndex = 0;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs2(Box2, { 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: [
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsxs2(Text3, { bold: true, color: "white", children: [
           categoryIcon,
           " ",
           category
@@ -127,45 +226,45 @@ function ConfigSelector({
           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,
+          return /* @__PURE__ */ jsxs2(Box2, { paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx3(Text3, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+            /* @__PURE__ */ jsx3(Box2, { width: 2, children: /* @__PURE__ */ jsx3(StatusIndicator, { status: item.status, isSelected: isItemSelected }) }),
+            /* @__PURE__ */ jsx3(Box2, { width: 28, children: /* @__PURE__ */ jsx3(
+              Text3,
               {
                 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 })
+            /* @__PURE__ */ jsx3(Box2, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: item.hint || "" }) }),
+            /* @__PURE__ */ jsx3(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" }),
+    /* @__PURE__ */ jsx3(Box2, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u2191\u2193" }),
       " navigate",
       "  ",
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "space" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "space" }),
       " toggle",
       "  ",
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "a" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "a" }),
       " all",
       "  ",
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "n" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "n" }),
       " none",
       "  ",
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "enter" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "enter" }),
       " apply",
       "  ",
-      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "q" }),
+      /* @__PURE__ */ jsx3(Text3, { 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: [
+    /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: selected.size }),
+      /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
         " item",
         selected.size !== 1 ? "s" : "",
         " selected"
@@ -174,109 +273,234 @@ function ConfigSelector({
   ] });
 }
 
-// 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
-    ] }) })
-  ] });
+// src/commands/install/components/RuleSelector.tsx
+import { useState as useState4, useMemo } from "react";
+import { Box as Box3, Text as Text4, useInput as useInput3, useApp as useApp3 } from "ink";
+import { getRulesByCategory } from "uilint-eslint";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function SeverityBadge({ severity }) {
+  if (severity === "error") {
+    return /* @__PURE__ */ jsx4(Text4, { color: "red", children: "error" });
+  }
+  if (severity === "warn") {
+    return /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "warn" });
+  }
+  return /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "off" });
 }
-function PendingTask({ task }) {
-  return /* @__PURE__ */ jsx3(Box2, { children: /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
-    "\u25CB ",
-    task.message
+function CategoryHeader({ name, icon }) {
+  return /* @__PURE__ */ jsx4(Box3, { marginTop: 1, marginBottom: 0, children: /* @__PURE__ */ jsxs3(Text4, { bold: true, color: "white", children: [
+    icon,
+    " ",
+    name
   ] }) });
 }
-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
+function RuleSelector({
+  onSubmit,
+  onBack,
+  onCancel
+}) {
+  const { exit } = useApp3();
+  const staticRules = useMemo(() => getRulesByCategory("static"), []);
+  const semanticRules = useMemo(() => getRulesByCategory("semantic"), []);
+  const allRules = useMemo(() => [...staticRules, ...semanticRules], [staticRules, semanticRules]);
+  const [cursor, setCursor] = useState4(0);
+  const [viewMode, setViewMode] = useState4("list");
+  const [ruleStates, setRuleStates] = useState4(
+    () => {
+      const map = /* @__PURE__ */ new Map();
+      for (const rule of staticRules) {
+        map.set(rule.id, {
+          enabled: true,
+          severity: rule.defaultSeverity === "off" ? "warn" : rule.defaultSeverity
         });
       }
-    } 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;
+      for (const rule of semanticRules) {
+        map.set(rule.id, {
+          enabled: false,
+          severity: rule.defaultSeverity === "off" ? "warn" : rule.defaultSeverity
+        });
       }
-    } 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 map;
+    }
+  );
+  const currentRule = allRules[cursor];
+  const currentState = currentRule ? ruleStates.get(currentRule.id) : void 0;
+  const toggleRule = () => {
+    if (!currentRule) return;
+    setRuleStates((prev) => {
+      const next = new Map(prev);
+      const current = next.get(currentRule.id);
+      next.set(currentRule.id, { ...current, enabled: !current.enabled });
+      return next;
+    });
+  };
+  const cycleSeverity = () => {
+    if (!currentRule) return;
+    setRuleStates((prev) => {
+      const next = new Map(prev);
+      const current = next.get(currentRule.id);
+      const newSeverity = current.severity === "error" ? "warn" : "error";
+      next.set(currentRule.id, { ...current, severity: newSeverity });
+      return next;
+    });
+  };
+  const handleSubmit = () => {
+    const configuredRules = [];
+    for (const rule of allRules) {
+      const state = ruleStates.get(rule.id);
+      if (state?.enabled) {
+        configuredRules.push({
+          rule,
+          severity: state.severity,
+          options: rule.defaultOptions
         });
       }
     }
+    onSubmit(configuredRules);
+  };
+  useInput3((input, key) => {
+    if (viewMode === "docs") {
+      if (key.escape || key.return || input === "d" || input === "q") {
+        setViewMode("list");
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : allRules.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < allRules.length - 1 ? prev + 1 : 0);
+    } else if (input === " ") {
+      toggleRule();
+    } else if (input === "s") {
+      cycleSeverity();
+    } else if (input === "d") {
+      setViewMode("docs");
+    } else if (key.return) {
+      handleSubmit();
+    } else if (key.escape || input === "q") {
+      onCancel?.();
+      exit();
+    } else if ((input === "b" || key.leftArrow) && onBack) {
+      onBack();
+    } else if (input === "a") {
+      setRuleStates((prev) => {
+        const next = new Map(prev);
+        for (const rule of allRules) {
+          const current = next.get(rule.id);
+          next.set(rule.id, { ...current, enabled: true });
+        }
+        return next;
+      });
+    } else if (input === "n") {
+      setRuleStates((prev) => {
+        const next = new Map(prev);
+        for (const rule of allRules) {
+          const current = next.get(rule.id);
+          next.set(rule.id, { ...current, enabled: false });
+        }
+        return next;
+      });
+    }
+  });
+  if (viewMode === "docs" && currentRule) {
+    const docLines = currentRule.docs.trim().split("\n").slice(0, 20);
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: currentRule.name }),
+        /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+          " - ",
+          currentRule.description
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [
+        docLines.map((line, i) => /* @__PURE__ */ jsx4(Text4, { dimColor: line.startsWith("#"), children: line }, i)),
+        currentRule.docs.split("\n").length > 20 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "... (truncated)" })
+      ] }),
+      /* @__PURE__ */ jsx4(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press any key to return to list" }) })
+    ] });
   }
-  return tasks;
+  const enabledCount = Array.from(ruleStates.values()).filter((s) => s.enabled).length;
+  const errorCount = Array.from(ruleStates.entries()).filter(
+    ([id, s]) => s.enabled && s.severity === "error"
+  ).length;
+  const warnCount = enabledCount - errorCount;
+  let globalIndex = 0;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Configure ESLint Rules" }) }),
+    /* @__PURE__ */ jsx4(CategoryHeader, { name: "Static Rules", icon: "\u{1F4CB}" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  Pattern-based, fast analysis" }),
+    staticRules.map((rule) => {
+      const itemIndex = globalIndex++;
+      const isCursor = itemIndex === cursor;
+      const state = ruleStates.get(rule.id);
+      return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 2, children: [
+        /* @__PURE__ */ jsx4(Text4, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+        /* @__PURE__ */ jsx4(Box3, { width: 3, children: /* @__PURE__ */ jsx4(Text4, { color: state.enabled ? "green" : void 0, dimColor: !state.enabled, children: state.enabled ? "\u2713" : "\u25CB" }) }),
+        /* @__PURE__ */ jsx4(Box3, { width: 30, children: /* @__PURE__ */ jsx4(
+          Text4,
+          {
+            color: isCursor ? "cyan" : void 0,
+            dimColor: !state.enabled,
+            bold: isCursor,
+            children: rule.name
+          }
+        ) }),
+        /* @__PURE__ */ jsx4(Box3, { width: 8, children: state.enabled ? /* @__PURE__ */ jsx4(SeverityBadge, { severity: state.severity }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "-" }) })
+      ] }, rule.id);
+    }),
+    /* @__PURE__ */ jsx4(CategoryHeader, { name: "Semantic Rules", icon: "\u{1F9E0}" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  LLM-powered analysis (requires Ollama)" }),
+    semanticRules.map((rule) => {
+      const itemIndex = globalIndex++;
+      const isCursor = itemIndex === cursor;
+      const state = ruleStates.get(rule.id);
+      return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 2, children: [
+        /* @__PURE__ */ jsx4(Text4, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+        /* @__PURE__ */ jsx4(Box3, { width: 3, children: /* @__PURE__ */ jsx4(Text4, { color: state.enabled ? "green" : void 0, dimColor: !state.enabled, children: state.enabled ? "\u2713" : "\u25CB" }) }),
+        /* @__PURE__ */ jsx4(Box3, { width: 30, children: /* @__PURE__ */ jsx4(
+          Text4,
+          {
+            color: isCursor ? "cyan" : void 0,
+            dimColor: !state.enabled,
+            bold: isCursor,
+            children: rule.name
+          }
+        ) }),
+        /* @__PURE__ */ jsx4(Box3, { width: 8, children: state.enabled ? /* @__PURE__ */ jsx4(SeverityBadge, { severity: state.severity }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "-" }) })
+      ] }, rule.id);
+    }),
+    currentRule && /* @__PURE__ */ jsx4(Box3, { marginTop: 1, paddingX: 2, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: currentRule.description }) }),
+    /* @__PURE__ */ jsx4(Box3, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "\u2191\u2193" }),
+      " navigate",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "space" }),
+      " toggle",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "s" }),
+      " severity",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "d" }),
+      " docs",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "a" }),
+      " all",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "n" }),
+      " none",
+      "  ",
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "enter" }),
+      " confirm"
+    ] }) }),
+    /* @__PURE__ */ jsx4(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: enabledCount }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " rules enabled (" }),
+      /* @__PURE__ */ jsx4(Text4, { color: "red", children: errorCount }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " errors, " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: warnCount }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " warnings)" })
+    ] }) })
+  ] });
 }
 
 // src/commands/install/installers/registry.ts
@@ -293,76 +517,138 @@ function getAllInstallers() {
 }
 
 // src/commands/install/components/InstallApp.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-function buildConfigItems(project, selections) {
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function buildConfigItemsForProject(project, selectedProject, 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 relevantTargets = targets.filter((target) => {
+      if (installer.id === "next" || installer.id === "vite") {
+        return target.path === selectedProject.path;
+      }
+      if (installer.id === "eslint") {
+        return target.path === selectedProject.path;
+      }
+      return true;
+    });
+    if (relevantTargets.length === 0) continue;
+    const displayInfo = {
+      next: { category: "UI Analysis", icon: "\u{1F50D}" },
+      vite: { category: "UI Analysis", icon: "\u{1F50D}" },
+      eslint: { category: "ESLint Rules", icon: "\u{1F4CB}" },
+      genstyleguide: { category: "Cursor Integration", icon: "\u{1F4DD}" },
+      skill: { category: "Cursor Integration", icon: "\u26A1" }
     };
-    const category = categoryMap[installer.id] || { name: "Other", icon: "\u2022" };
+    const info = displayInfo[installer.id] || { category: "Other", icon: "\u2022" };
+    for (const target of relevantTargets) {
+      items.push({
+        id: `${installer.id}:${target.id}`,
+        label: installer.name,
+        hint: target.hint,
+        status: target.isInstalled ? "installed" : "not_installed",
+        category: info.category,
+        categoryIcon: info.icon
+      });
+    }
+  }
+  return items;
+}
+function buildGlobalConfigItems(selections) {
+  const items = [];
+  for (const selection of selections) {
+    const { installer, targets } = selection;
+    if (installer.id !== "genstyleguide" && installer.id !== "skill") {
+      continue;
+    }
+    const displayInfo = {
+      genstyleguide: { category: "Cursor Integration", icon: "\u{1F4DD}" },
+      skill: { category: "Cursor Integration", icon: "\u26A1" }
+    };
+    const info = displayInfo[installer.id] || { category: "Other", icon: "\u2022" };
     for (const target of targets) {
       items.push({
         id: `${installer.id}:${target.id}`,
-        label: target.label,
+        label: installer.name,
         hint: target.hint,
         status: target.isInstalled ? "installed" : "not_installed",
-        category: category.name,
-        categoryIcon: category.icon
+        category: info.category,
+        categoryIcon: info.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: [
+  return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "\u25C6 UILint" }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " v0.5.0" }),
+    subtitle && /* @__PURE__ */ jsxs4(Text5, { 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 FeatureConfig({
+  selectedProject,
+  configItems,
+  canGoBack,
+  onSubmit,
+  onBack,
+  onCancel
+}) {
+  useInput4((input, key) => {
+    if ((input === "b" || key.leftArrow) && canGoBack) {
+      onBack();
+    }
+  });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    selectedProject && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Project: " }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: selectedProject.name }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        " (",
+        selectedProject.hint,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(
+      ConfigSelector,
+      {
+        items: configItems,
+        onSubmit,
+        onCancel
+      }
+    ),
+    canGoBack && /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      "Press ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "b" }),
+      " or ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2190" }),
+      " to select a different project"
+    ] }) })
+  ] });
 }
 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);
+  const { exit } = useApp4();
+  const [phase, setPhase] = useState5("scanning");
+  const [project, setProject] = useState5(null);
+  const [detectedProjects, setDetectedProjects] = useState5([]);
+  const [selectedProject, setSelectedProject] = useState5(null);
+  const [selections, setSelections] = useState5([]);
+  const [configItems, setConfigItems] = useState5([]);
+  const [selectedFeatureIds, setSelectedFeatureIds] = useState5([]);
+  const [error, setError] = useState5(null);
+  const isEslintSelected = selectedFeatureIds.some((id) => id.startsWith("eslint:"));
   useEffect2(() => {
-    if (state !== "scanning") return;
+    if (phase !== "scanning") return;
     projectPromise.then((proj) => {
       setProject(proj);
+      const projects = getDetectedProjects(proj);
+      setDetectedProjects(projects);
       const installers2 = getAllInstallers();
       const initialSelections = installers2.filter((installer) => installer.isApplicable(proj)).map((installer) => {
         const targets = installer.getTargets(proj);
@@ -374,16 +660,55 @@ function InstallApp({
         };
       });
       setSelections(initialSelections);
-      const items = buildConfigItems(proj, initialSelections);
-      setConfigItems(items);
-      setState("configuring");
+      if (projects.length === 1) {
+        const singleProject = projects[0];
+        setSelectedProject(singleProject);
+        const items = buildConfigItemsForProject(proj, singleProject, initialSelections);
+        setConfigItems(items);
+        setPhase("configure-features");
+      } else if (projects.length === 0) {
+        setPhase("configure-features");
+        const items = buildGlobalConfigItems(initialSelections);
+        setConfigItems(items);
+      } else {
+        setPhase("select-project");
+      }
     }).catch((err) => {
       setError(err);
-      setState("error");
+      setPhase("error");
       onError?.(err);
     });
-  }, [state, projectPromise, onError]);
-  const handleConfigSubmit = (selectedIds) => {
+  }, [phase, projectPromise, onError]);
+  const handleProjectSelect = (selected) => {
+    setSelectedProject(selected);
+    if (project) {
+      const items = buildConfigItemsForProject(project, selected, selections);
+      setConfigItems(items);
+    }
+    setPhase("configure-features");
+  };
+  const handleBackToProject = () => {
+    if (detectedProjects.length > 1) {
+      setSelectedProject(null);
+      setPhase("select-project");
+    }
+  };
+  const handleFeatureSubmit = (selectedIds) => {
+    setSelectedFeatureIds(selectedIds);
+    const eslintSelected = selectedIds.some((id) => id.startsWith("eslint:"));
+    if (eslintSelected) {
+      setPhase("configure-eslint");
+    } else {
+      finishInstallation(selectedIds, void 0);
+    }
+  };
+  const handleRuleSubmit = (configuredRules) => {
+    finishInstallation(selectedFeatureIds, configuredRules);
+  };
+  const handleBackToFeatures = () => {
+    setPhase("configure-features");
+  };
+  const finishInstallation = (selectedIds, eslintRules) => {
     const selectedSet = new Set(selectedIds);
     const updatedSelections = selections.map((sel) => {
       const selectedTargets = sel.targets.filter(
@@ -396,62 +721,78 @@ function InstallApp({
       };
     });
     setSelections(updatedSelections);
-    onComplete(updatedSelections);
+    onComplete(updatedSelections, eslintRules);
   };
   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 (phase === "scanning") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Header, { subtitle: "Install" }),
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx5(Spinner, {}),
+        /* @__PURE__ */ jsx5(Text5, { 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 (phase === "error") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Header, {}),
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: "red", children: "\u2717 " }),
+        /* @__PURE__ */ jsx5(Text5, { 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,
+  if (phase === "select-project") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Header, { subtitle: "Install" }),
+      /* @__PURE__ */ jsx5(
+        ProjectSelector,
         {
-          items: configItems,
-          onSubmit: handleConfigSubmit,
+          projects: detectedProjects,
+          onSelect: handleProjectSelect,
           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 (phase === "configure-features" && project && configItems.length > 0) {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Header, { subtitle: "Features" }),
+      /* @__PURE__ */ jsx5(
+        FeatureConfig,
+        {
+          selectedProject,
+          configItems,
+          canGoBack: detectedProjects.length > 1,
+          onSubmit: handleFeatureSubmit,
+          onBack: handleBackToProject,
+          onCancel: handleCancel
+        }
+      )
     ] });
   }
-  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!" })
-      ] })
+  if (phase === "configure-eslint") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Header, { subtitle: "ESLint Rules" }),
+      selectedProject && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Project: " }),
+        /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: selectedProject.name })
+      ] }),
+      /* @__PURE__ */ jsx5(
+        RuleSelector,
+        {
+          onSubmit: handleRuleSubmit,
+          onBack: handleBackToFeatures,
+          onCancel: handleCancel
+        }
+      )
     ] });
   }
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(Header, {}),
-    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Loading..." })
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Header, {}),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Loading..." })
   ] });
 }
 
@@ -1393,14 +1734,14 @@ async function analyze(projectPath = process.cwd()) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync,
   writeFileSync as writeFileSync5,
   readFileSync as readFileSync8,
   unlinkSync,
   chmodSync
 } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname4 } from "path";
 
 // src/utils/react-inject.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
@@ -2441,6 +2782,145 @@ async function installNextUILintRoutes(opts) {
   );
 }
 
+// src/utils/prettier.ts
+import { existsSync as existsSync10 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { join as join10, dirname as dirname3 } from "path";
+function getPrettierPath(projectPath) {
+  const localPath = join10(projectPath, "node_modules", ".bin", "prettier");
+  if (existsSync10(localPath)) return localPath;
+  let dir = projectPath;
+  for (let i = 0; i < 10; i++) {
+    const binPath = join10(dir, "node_modules", ".bin", "prettier");
+    if (existsSync10(binPath)) return binPath;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getPmRunner(pm) {
+  switch (pm) {
+    case "pnpm":
+      return { command: "pnpm", args: ["exec"] };
+    case "yarn":
+      return { command: "yarn", args: [] };
+    case "bun":
+      return { command: "bunx", args: [] };
+    case "npm":
+    default:
+      return { command: "npx", args: [] };
+  }
+}
+async function formatWithPrettier(filePath, projectPath) {
+  const prettierPath = getPrettierPath(projectPath);
+  if (!prettierPath) {
+    const pm = detectPackageManager(projectPath);
+    const runner = getPmRunner(pm);
+    return new Promise((resolve) => {
+      const args = [...runner.args, "prettier", "--write", filePath];
+      const child = spawn2(runner.command, args, {
+        cwd: projectPath,
+        stdio: "pipe",
+        shell: process.platform === "win32"
+      });
+      let stderr = "";
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("error", () => {
+        resolve({ formatted: false, error: "prettier not available" });
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve({ formatted: true });
+        } else {
+          resolve({ formatted: false, error: stderr || "prettier failed" });
+        }
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    const child = spawn2(prettierPath, ["--write", filePath], {
+      cwd: projectPath,
+      stdio: "pipe",
+      shell: process.platform === "win32"
+    });
+    let stderr = "";
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (err) => {
+      resolve({ formatted: false, error: err.message });
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ formatted: true });
+      } else {
+        resolve({ formatted: false, error: stderr || `exit code ${code}` });
+      }
+    });
+  });
+}
+async function formatFilesWithPrettier(filePaths, projectPath) {
+  if (filePaths.length === 0) {
+    return { formatted: [], failed: [] };
+  }
+  const prettierPath = getPrettierPath(projectPath);
+  const formatted = [];
+  const failed = [];
+  if (!prettierPath) {
+    const pm = detectPackageManager(projectPath);
+    const runner = getPmRunner(pm);
+    return new Promise((resolve) => {
+      const args = [...runner.args, "prettier", "--write", ...filePaths];
+      const child = spawn2(runner.command, args, {
+        cwd: projectPath,
+        stdio: "pipe",
+        shell: process.platform === "win32"
+      });
+      child.on("error", () => {
+        resolve({ formatted: [], failed: filePaths });
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve({ formatted: filePaths, failed: [] });
+        } else {
+          resolve({ formatted: [], failed: filePaths });
+        }
+      });
+    });
+  }
+  return new Promise((resolve) => {
+    const child = spawn2(prettierPath, ["--write", ...filePaths], {
+      cwd: projectPath,
+      stdio: "pipe",
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => {
+      resolve({ formatted: [], failed: filePaths });
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ formatted: filePaths, failed: [] });
+      } else {
+        Promise.all(
+          filePaths.map(async (fp) => {
+            const result = await formatWithPrettier(fp, projectPath);
+            if (result.formatted) {
+              formatted.push(fp);
+            } else {
+              failed.push(fp);
+            }
+          })
+        ).then(() => {
+          resolve({ formatted, failed });
+        });
+      }
+    });
+  });
+}
+
 // src/commands/install/execute.ts
 async function executeAction(action, options) {
   const { dryRun = false } = options;
@@ -2454,7 +2934,7 @@ async function executeAction(action, options) {
             wouldDo: `Create directory: ${action.path}`
           };
         }
-        if (!existsSync10(action.path)) {
+        if (!existsSync11(action.path)) {
           mkdirSync(action.path, { recursive: true });
         }
         return { action, success: true };
@@ -2467,8 +2947,8 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname3(action.path);
-        if (!existsSync10(dir)) {
+        const dir = dirname4(action.path);
+        if (!existsSync11(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, action.content, "utf-8");
@@ -2486,15 +2966,15 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync10(action.path)) {
+        if (existsSync11(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)) {
+        const dir = dirname4(action.path);
+        if (!existsSync11(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
@@ -2508,7 +2988,7 @@ async function executeAction(action, options) {
             wouldDo: `Delete file: ${action.path}`
           };
         }
-        if (existsSync10(action.path)) {
+        if (existsSync11(action.path)) {
           unlinkSync(action.path);
         }
         return { action, success: true };
@@ -2521,7 +3001,7 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync10(action.path)) {
+        if (existsSync11(action.path)) {
           const content = readFileSync8(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
@@ -2739,8 +3219,71 @@ function buildSummary(actionsPerformed, dependencyResults, items) {
     viteApp
   };
 }
+function collectFormattableFiles(actionsPerformed) {
+  const formattableExtensions = /* @__PURE__ */ new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json"
+  ]);
+  const files = [];
+  for (const result of actionsPerformed) {
+    if (!result.success) continue;
+    const { action } = result;
+    let filePath;
+    switch (action.type) {
+      case "create_file":
+        filePath = action.path;
+        break;
+      case "merge_json":
+        filePath = action.path;
+        break;
+      case "append_to_file":
+        filePath = action.path;
+        break;
+      case "inject_eslint":
+        filePath = action.configPath;
+        break;
+      case "inject_next_config":
+      case "inject_vite_config":
+      case "inject_react":
+        break;
+    }
+    if (filePath) {
+      const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+      if (formattableExtensions.has(ext)) {
+        files.push(filePath);
+      }
+    }
+  }
+  return files;
+}
+function getProjectPathFromActions(actionsPerformed) {
+  for (const result of actionsPerformed) {
+    if (!result.success) continue;
+    const { action } = result;
+    switch (action.type) {
+      case "inject_eslint":
+        return action.packagePath;
+      case "inject_react":
+      case "inject_next_config":
+      case "inject_vite_config":
+      case "install_next_routes":
+        return action.projectPath;
+    }
+  }
+  return void 0;
+}
 async function execute(plan, options = {}) {
-  const { dryRun = false, installDependencies: installDependencies2 = installDependencies } = options;
+  const {
+    dryRun = false,
+    installDependencies: installDependencies2 = installDependencies,
+    projectPath,
+    skipPrettier = false
+  } = options;
   const actionsPerformed = [];
   const dependencyResults = [];
   for (const action of plan.actions) {
@@ -2774,6 +3317,18 @@ async function execute(plan, options = {}) {
       });
     }
   }
+  if (!dryRun && !skipPrettier) {
+    const filesToFormat = collectFormattableFiles(actionsPerformed);
+    if (filesToFormat.length > 0) {
+      const formatProjectPath = projectPath || plan.dependencies[0]?.packagePath || getProjectPathFromActions(actionsPerformed);
+      if (formatProjectPath) {
+        await formatFilesWithPrettier(filesToFormat, formatProjectPath).catch(
+          () => {
+          }
+        );
+      }
+    }
+  }
   const actionsFailed = actionsPerformed.filter((r) => !r.success);
   const depsFailed = dependencyResults.filter((r) => !r.success);
   const success = actionsFailed.length === 0 && depsFailed.length === 0;
@@ -2807,10 +3362,10 @@ async function execute(plan, options = {}) {
 }
 
 // src/commands/install-ui.tsx
-import { ruleRegistry as ruleRegistry2 } from "uilint-eslint";
+import { ruleRegistry as ruleRegistry3 } from "uilint-eslint";
 
 // src/commands/install/installers/genstyleguide.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var genstyleguideInstaller = {
   id: "genstyleguide",
   name: "/genstyleguide command",
@@ -2820,7 +3375,7 @@ var genstyleguideInstaller = {
     return true;
   },
   getTargets(project) {
-    const commandPath = join10(project.cursorDir.path, "commands", "genstyleguide.md");
+    const commandPath = join11(project.cursorDir.path, "commands", "genstyleguide.md");
     const isInstalled = project.commands.genstyleguide;
     return [
       {
@@ -2833,7 +3388,7 @@ var genstyleguideInstaller = {
   },
   plan(targets, config, project) {
     const actions = [];
-    const commandsDir = join10(project.cursorDir.path, "commands");
+    const commandsDir = join11(project.cursorDir.path, "commands");
     if (!project.cursorDir.exists) {
       actions.push({
         type: "create_directory",
@@ -2846,7 +3401,7 @@ var genstyleguideInstaller = {
     });
     actions.push({
       type: "create_file",
-      path: join10(commandsDir, "genstyleguide.md"),
+      path: join11(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
     return {
@@ -2876,8 +3431,8 @@ var genstyleguideInstaller = {
 };
 
 // src/commands/install/installers/skill.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
 var skillInstaller = {
   id: "skill",
   name: "UI Consistency Agent skill",
@@ -2887,9 +3442,9 @@ var skillInstaller = {
     return true;
   },
   getTargets(project) {
-    const skillsDir = join11(project.cursorDir.path, "skills", "ui-consistency-enforcer");
-    const skillMdPath = join11(skillsDir, "SKILL.md");
-    const isInstalled = existsSync11(skillMdPath);
+    const skillsDir = join12(project.cursorDir.path, "skills", "ui-consistency-enforcer");
+    const skillMdPath = join12(skillsDir, "SKILL.md");
+    const isInstalled = existsSync12(skillMdPath);
     return [
       {
         id: "ui-consistency-skill",
@@ -2908,21 +3463,21 @@ var skillInstaller = {
         path: project.cursorDir.path
       });
     }
-    const skillsDir = join11(project.cursorDir.path, "skills");
+    const skillsDir = join12(project.cursorDir.path, "skills");
     actions.push({
       type: "create_directory",
       path: skillsDir
     });
     try {
       const skill = loadSkill("ui-consistency-enforcer");
-      const skillDir = join11(skillsDir, skill.name);
+      const skillDir = join12(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(
+        const filePath = join12(skillDir, file.relativePath);
+        const fileDir = join12(
           skillDir,
           file.relativePath.split("/").slice(0, -1).join("/")
         );
@@ -2979,13 +3534,19 @@ var skillInstaller = {
 };
 
 // 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);
+import { join as join13 } from "path";
+import { ruleRegistry as ruleRegistry2, getRulesByCategory as getRulesByCategory2 } from "uilint-eslint";
 function toInstallSpecifier(pkgName) {
   return pkgName;
 }
+function formatRuleOption(rule) {
+  const severityBadge = rule.defaultSeverity === "error" ? pc.red("error") : pc.yellow("warn");
+  return {
+    value: rule.id,
+    label: `${rule.name}`,
+    hint: `${rule.description} [${severityBadge}]`
+  };
+}
 var eslintInstaller = {
   id: "eslint",
   name: "ESLint plugin",
@@ -3004,20 +3565,130 @@ var eslintInstaller = {
     }));
   },
   async configure(targets, project) {
-    const selectedRules = ruleRegistry;
-    return {
-      selectedRules
-    };
+    const staticRules = getRulesByCategory2("static");
+    const semanticRules = getRulesByCategory2("semantic");
+    const installMode = await select({
+      message: "How would you like to configure UILint ESLint rules?",
+      options: [
+        {
+          value: "recommended",
+          label: "Recommended (static rules only)",
+          hint: "Best for most projects - fast and reliable"
+        },
+        {
+          value: "strict",
+          label: "Strict (all rules including semantic)",
+          hint: "Includes LLM-powered analysis - requires Ollama"
+        },
+        {
+          value: "custom",
+          label: "Custom selection",
+          hint: "Choose individual rules and configure severity"
+        }
+      ]
+    });
+    let selectedRuleIds;
+    let configuredRules;
+    if (installMode === "recommended") {
+      configuredRules = staticRules.map((rule) => ({
+        rule,
+        severity: rule.defaultSeverity,
+        options: rule.defaultOptions
+      }));
+    } else if (installMode === "strict") {
+      configuredRules = ruleRegistry2.map((rule) => ({
+        rule,
+        severity: rule.defaultSeverity,
+        options: rule.defaultOptions
+      }));
+    } else {
+      log(pc.dim("\n\u{1F4CB} Static rules (pattern-based, fast):"));
+      const selectedStaticIds = await multiselect({
+        message: "Select static rules to enable:",
+        options: staticRules.map(formatRuleOption),
+        initialValues: staticRules.map((r) => r.id)
+      });
+      const includeSemanticRules = await confirm({
+        message: `Include semantic rules? ${pc.dim(
+          "(requires Ollama for LLM analysis)"
+        )}`,
+        initialValue: false
+      });
+      let selectedSemanticIds = [];
+      if (includeSemanticRules) {
+        log(
+          pc.dim("\n\u{1F9E0} Semantic rules (LLM-powered, slower):")
+        );
+        selectedSemanticIds = await multiselect({
+          message: "Select semantic rules:",
+          options: semanticRules.map(formatRuleOption),
+          initialValues: semanticRules.map((r) => r.id)
+        });
+      }
+      selectedRuleIds = [...selectedStaticIds, ...selectedSemanticIds];
+      const configureSeverity = await confirm({
+        message: "Would you like to customize severity levels?",
+        initialValue: false
+      });
+      configuredRules = [];
+      for (const ruleId of selectedRuleIds) {
+        const rule = ruleRegistry2.find((r) => r.id === ruleId);
+        if (configureSeverity) {
+          const severity = await select({
+            message: `${rule.name} - severity:`,
+            options: [
+              {
+                value: rule.defaultSeverity,
+                label: `${rule.defaultSeverity} (default)`
+              },
+              ...rule.defaultSeverity !== "error" ? [{ value: "error", label: "error" }] : [],
+              ...rule.defaultSeverity !== "warn" ? [{ value: "warn", label: "warn" }] : []
+            ],
+            initialValue: rule.defaultSeverity
+          });
+          configuredRules.push({
+            rule,
+            severity,
+            options: rule.defaultOptions
+          });
+        } else {
+          configuredRules.push({
+            rule,
+            severity: rule.defaultSeverity,
+            options: rule.defaultOptions
+          });
+        }
+      }
+    }
+    const errorCount = configuredRules.filter(
+      (r) => r.severity === "error"
+    ).length;
+    const warnCount = configuredRules.filter(
+      (r) => r.severity === "warn"
+    ).length;
+    log("");
+    note(
+      configuredRules.map(
+        (cr) => `${cr.severity === "error" ? "\u{1F534}" : "\u{1F7E1}"} ${cr.rule.name} (${cr.severity})`
+      ).join("\n"),
+      `Selected ${configuredRules.length} rules (${errorCount} errors, ${warnCount} warnings)`
+    );
+    return { configuredRules };
   },
   plan(targets, config, project) {
     const actions = [];
     const dependencies = [];
     const eslintConfig = config;
-    const { selectedRules } = eslintConfig;
+    const { configuredRules } = eslintConfig;
+    const rulesWithSeverity = configuredRules.map((cr) => ({
+      ...cr.rule,
+      defaultSeverity: cr.severity,
+      defaultOptions: cr.options
+    }));
     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");
+      const rulesDir = join13(target.path, ".uilint", "rules");
       actions.push({
         type: "create_directory",
         path: rulesDir
@@ -3031,11 +3702,11 @@ var eslintInstaller = {
         type: "inject_eslint",
         packagePath: target.path,
         configPath: pkgInfo.eslintConfigPath,
-        rules: selectedRules,
+        rules: rulesWithSeverity,
         hasExistingRules: pkgInfo.hasUilintRules
       });
     }
-    const gitignorePath = join12(project.workspaceRoot, ".gitignore");
+    const gitignorePath = join13(project.workspaceRoot, ".gitignore");
     actions.push({
       type: "append_to_file",
       path: gitignorePath,
@@ -3058,7 +3729,7 @@ var eslintInstaller = {
       };
       yield {
         type: "progress",
-        message: `Injecting ${eslintConfig.selectedRules.length} rules`,
+        message: `Injecting ${eslintConfig.configuredRules.length} rules`,
         detail: `\u2192 ${target.hint}`
       };
     }
@@ -3238,8 +3909,8 @@ registerInstaller(nextOverlayInstaller);
 registerInstaller(viteOverlayInstaller);
 
 // src/commands/install-ui.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
-function selectionsToUserChoices(selections, project) {
+import { jsx as jsx6 } from "react/jsx-runtime";
+function selectionsToUserChoices(selections, project, eslintRules) {
   const items = [];
   const choices = { items };
   for (const selection of selections) {
@@ -3253,7 +3924,13 @@ function selectionsToUserChoices(selections, project) {
       items.push("eslint");
       choices.eslint = {
         packagePaths: targets.map((t) => t.path),
-        selectedRules: ruleRegistry2
+        // Use configured rules if provided, otherwise fall back to all rules
+        selectedRules: eslintRules ? eslintRules.map((cr) => ({
+          ...cr.rule,
+          // Override severity with user's selection
+          defaultSeverity: cr.severity,
+          defaultOptions: cr.options
+        })) : ruleRegistry3
       };
     } else if (installer.id === "next") {
       items.push("next");
@@ -3295,20 +3972,23 @@ async function installUI(options = {}, executeOptions = {}) {
   }
   const projectPromise = analyze(projectPath);
   const { waitUntilExit } = render(
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
       InstallApp,
       {
         projectPromise,
-        onComplete: async (selections) => {
+        onComplete: async (selections, eslintRules) => {
           const project = await projectPromise;
-          const choices = selectionsToUserChoices(selections, project);
+          const choices = selectionsToUserChoices(selections, project, eslintRules);
           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);
+          const result = await execute(plan, {
+            ...executeOptions,
+            projectPath: project.projectPath
+          });
           if (result.success) {
             console.log("\n\u2713 Installation completed successfully!");
           } else {
@@ -3328,4 +4008,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-OEFHX4FG.js.map
+//# sourceMappingURL=install-ui-KI7YHOVZ.js.map