uilint 0.2.8 → 0.2.9

package/dist/index.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  detectNextAppRouter,
+  findNextAppRouterProjects
+} from "./chunk-RHTG6DUD.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -357,8 +361,8 @@ import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 function getCLIVersion() {
   try {
-    const __dirname3 = dirname(fileURLToPath(import.meta.url));
-    const pkgPath = join2(__dirname3, "..", "..", "package.json");
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join2(__dirname, "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
@@ -374,17 +378,6 @@ function intro2(title) {
 function outro2(message) {
   p.outro(pc.green(message));
 }
-function cancel2(message = "Operation cancelled.") {
-  p.cancel(pc.yellow(message));
-  process.exit(0);
-}
-function handleCancel(value) {
-  if (p.isCancel(value)) {
-    cancel2();
-    process.exit(0);
-  }
-  return value;
-}
 async function withSpinner(message, fn) {
   const s = p.spinner();
   s.start(message);
@@ -415,34 +408,6 @@ function logWarning(message) {
 function logError(message) {
   p.log.error(message);
 }
-async function select2(options) {
-  const result = await p.select({
-    message: options.message,
-    options: options.options,
-    initialValue: options.initialValue
-  });
-  return handleCancel(result);
-}
-async function confirm2(options) {
-  const result = await p.confirm({
-    message: options.message,
-    initialValue: options.initialValue ?? true
-  });
-  return handleCancel(result);
-}
-async function text2(options) {
-  const result = await p.text(options);
-  return handleCancel(result);
-}
-async function multiselect2(options) {
-  const result = await p.multiselect({
-    message: options.message,
-    options: options.options,
-    required: options.required,
-    initialValues: options.initialValues
-  });
-  return handleCancel(result);
-}
 
 // src/utils/output.ts
 import chalk from "chalk";
@@ -460,9 +425,9 @@ function envTruthy(name) {
   if (!v) return false;
   return v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes";
 }
-function preview(text3, maxLen) {
-  if (text3.length <= maxLen) return text3;
-  return text3.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text3.slice(-maxLen);
+function preview(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text2.slice(-maxLen);
 }
 function debugEnabled(options) {
   return Boolean(options.debug) || envTruthy("UILINT_DEBUG");
@@ -913,9 +878,9 @@ function envTruthy2(name) {
   if (!v) return false;
   return v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes";
 }
-function preview2(text3, maxLen) {
-  if (text3.length <= maxLen) return text3;
-  return text3.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text3.slice(-maxLen);
+function preview2(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text2.slice(-maxLen);
 }
 function debugEnabled2(options) {
   return Boolean(options.debug) || envTruthy2("UILINT_DEBUG");
@@ -1474,3644 +1439,239 @@ async function update(options) {
   await flushLangfuse();
 }
 
-// src/commands/install.ts
-import { join as join16 } from "path";
-import { ruleRegistry as ruleRegistry2 } from "uilint-eslint";
-
-// src/commands/install/analyze.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { join as join8 } from "path";
-import { findWorkspaceRoot as findWorkspaceRoot5 } from "uilint-core/node";
+// src/commands/serve.ts
+import { existsSync as existsSync5, statSync as statSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname6, resolve as resolve5, relative, join as join4, parse as parse2 } from "path";
+import { WebSocketServer, WebSocket } from "ws";
+import { watch } from "chokidar";
+import {
+  findWorkspaceRoot as findWorkspaceRoot4,
+  getVisionAnalyzer as getCoreVisionAnalyzer
+} from "uilint-core/node";
 
-// src/utils/next-detect.ts
-import { existsSync as existsSync4, readdirSync } from "fs";
-import { join as join3 } from "path";
-function fileExists(projectPath, relPath) {
-  return existsSync4(join3(projectPath, relPath));
-}
-function detectNextAppRouter(projectPath) {
-  const roots = ["app", join3("src", "app")];
-  const candidates = [];
-  let chosenRoot = null;
-  for (const root of roots) {
-    if (existsSync4(join3(projectPath, root))) {
-      chosenRoot = root;
-      break;
+// src/utils/vision-run.ts
+import { dirname as dirname5, join as join3, parse } from "path";
+import { existsSync as existsSync4, statSync as statSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import {
+  ensureOllamaReady as ensureOllamaReady5,
+  findStyleGuidePath as findStyleGuidePath4,
+  findUILintStyleGuideUpwards as findUILintStyleGuideUpwards3,
+  readStyleGuide as readStyleGuide4,
+  VisionAnalyzer,
+  UILINT_DEFAULT_VISION_MODEL
+} from "uilint-core/node";
+async function resolveVisionStyleGuide(args) {
+  const projectPath = args.projectPath;
+  const startDir = args.startDir ?? projectPath;
+  if (args.styleguide) {
+    const styleguideArg = resolvePathSpecifier(args.styleguide, projectPath);
+    if (existsSync4(styleguideArg)) {
+      const stat = statSync2(styleguideArg);
+      if (stat.isFile()) {
+        return {
+          styleguideLocation: styleguideArg,
+          styleGuide: await readStyleGuide4(styleguideArg)
+        };
+      }
+      if (stat.isDirectory()) {
+        const found = findStyleGuidePath4(styleguideArg);
+        return {
+          styleguideLocation: found,
+          styleGuide: found ? await readStyleGuide4(found) : null
+        };
+      }
     }
+    return { styleGuide: null, styleguideLocation: null };
   }
-  if (!chosenRoot) return null;
-  const entryCandidates = [
-    join3(chosenRoot, "layout.tsx"),
-    join3(chosenRoot, "layout.jsx"),
-    join3(chosenRoot, "layout.ts"),
-    join3(chosenRoot, "layout.js"),
-    // Fallbacks (less ideal, but can work):
-    join3(chosenRoot, "page.tsx"),
-    join3(chosenRoot, "page.jsx")
-  ];
-  for (const rel of entryCandidates) {
-    if (fileExists(projectPath, rel)) candidates.push(rel);
-  }
+  const upwards = findUILintStyleGuideUpwards3(startDir);
+  const fallback = upwards ?? findStyleGuidePath4(projectPath);
   return {
-    appRoot: chosenRoot,
-    appRootAbs: join3(projectPath, chosenRoot),
-    candidates
+    styleguideLocation: fallback,
+    styleGuide: fallback ? await readStyleGuide4(fallback) : null
   };
 }
-var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  "dist",
-  "build",
-  "out",
-  ".turbo",
-  ".vercel",
-  ".cursor",
-  "coverage",
-  ".uilint"
-]);
-function findNextAppRouterProjects(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 = detectNextAppRouter(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(join3(dir, ent.name), depth + 1);
-    }
-  }
-  walk(rootDir, 0);
-  return results;
+var ollamaReadyOnce = /* @__PURE__ */ new Map();
+async function ensureOllamaReadyCached(params) {
+  const key = `${params.baseUrl}::${params.model}`;
+  const existing = ollamaReadyOnce.get(key);
+  if (existing) return existing;
+  const p2 = ensureOllamaReady5({ model: params.model, baseUrl: params.baseUrl }).then(() => void 0).catch((e) => {
+    ollamaReadyOnce.delete(key);
+    throw e;
+  });
+  ollamaReadyOnce.set(key, p2);
+  return p2;
 }
-
-// src/utils/vite-detect.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } 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 (existsSync5(join4(projectPath, rel))) return rel;
-  }
-  return null;
+function writeVisionDebugDump(params) {
+  const resolvedDirOrFile = resolvePathSpecifier(
+    params.dumpPath,
+    process.cwd()
+  );
+  const safeStamp = params.now.toISOString().replace(/[:.]/g, "-");
+  const dumpFile = resolvedDirOrFile.endsWith(".json") || resolvedDirOrFile.endsWith(".jsonl") ? resolvedDirOrFile : `${resolvedDirOrFile}/vision-debug-${safeStamp}.json`;
+  mkdirSync3(dirname5(dumpFile), { recursive: true });
+  writeFileSync3(
+    dumpFile,
+    JSON.stringify(
+      {
+        version: 1,
+        timestamp: params.now.toISOString(),
+        runtime: params.runtime,
+        metadata: params.metadata ?? null,
+        inputs: {
+          imageBase64: params.includeSensitive ? params.inputs.imageBase64 : "(omitted; set debugDumpIncludeSensitive=true)",
+          manifest: params.inputs.manifest,
+          styleguideLocation: params.inputs.styleguideLocation,
+          styleGuide: params.includeSensitive ? params.inputs.styleGuide : "(omitted; set debugDumpIncludeSensitive=true)"
+        }
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+  return dumpFile;
 }
-function looksLikeReactPackage(projectPath) {
-  try {
-    const pkgPath = join4(projectPath, "package.json");
-    if (!existsSync5(pkgPath)) return false;
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-    return "react" in deps || "react-dom" in deps;
-  } catch {
-    return false;
+async function runVisionAnalysis(args) {
+  const visionModel = args.model || UILINT_DEFAULT_VISION_MODEL;
+  const baseUrl = args.baseUrl ?? "http://localhost:11434";
+  let styleGuide = null;
+  let styleguideLocation = null;
+  if (args.styleGuide !== void 0) {
+    styleGuide = args.styleGuide;
+    styleguideLocation = args.styleguideLocation ?? null;
+  } else {
+    args.onPhase?.("Resolving styleguide...");
+    const resolved = await resolveVisionStyleGuide({
+      projectPath: args.projectPath,
+      styleguide: args.styleguide,
+      startDir: args.styleguideStartDir
+    });
+    styleGuide = resolved.styleGuide;
+    styleguideLocation = resolved.styleguideLocation;
   }
-}
-function fileExists2(projectPath, relPath) {
-  return existsSync5(join4(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 = [
-    join4(entryRoot, "main.tsx"),
-    join4(entryRoot, "main.jsx"),
-    join4(entryRoot, "main.ts"),
-    join4(entryRoot, "main.js")
-  ];
-  for (const rel of entryCandidates) {
-    if (fileExists2(projectPath, rel)) candidates.push(rel);
+  if (!args.skipEnsureOllama) {
+    args.onPhase?.("Preparing Ollama...");
+    await ensureOllamaReadyCached({ model: visionModel, baseUrl });
   }
-  const fallbackCandidates = [
-    join4(entryRoot, "App.tsx"),
-    join4(entryRoot, "App.jsx")
-  ];
-  for (const rel of fallbackCandidates) {
-    if (!candidates.includes(rel) && fileExists2(projectPath, rel)) {
-      candidates.push(rel);
-    }
+  if (args.debugDump) {
+    writeVisionDebugDump({
+      dumpPath: args.debugDump,
+      now: /* @__PURE__ */ new Date(),
+      runtime: { visionModel, baseUrl },
+      inputs: {
+        imageBase64: args.imageBase64,
+        manifest: args.manifest,
+        styleguideLocation,
+        styleGuide
+      },
+      includeSensitive: Boolean(args.debugDumpIncludeSensitive),
+      metadata: args.debugDumpMetadata
+    });
   }
+  const analyzer = args.analyzer ?? new VisionAnalyzer({
+    baseUrl: args.baseUrl,
+    visionModel
+  });
+  args.onPhase?.(`Analyzing ${args.manifest.length} elements...`);
+  const result = await analyzer.analyzeScreenshot(
+    args.imageBase64,
+    args.manifest,
+    {
+      styleGuide,
+      onProgress: args.onProgress
+    }
+  );
+  args.onPhase?.(
+    `Done (${result.issues.length} issues, ${result.analysisTime}ms)`
+  );
   return {
-    configFile,
-    configFileAbs: join4(projectPath, configFile),
-    entryRoot,
-    candidates
+    issues: result.issues,
+    analysisTime: result.analysisTime,
+    // Prompt is available in newer uilint-core versions; keep this resilient across versions.
+    prompt: result.prompt,
+    rawResponse: result.rawResponse,
+    styleguideLocation,
+    visionModel,
+    baseUrl
   };
 }
-var DEFAULT_IGNORE_DIRS2 = /* @__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_DIRS2;
-  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 = 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(".") && ent.name !== ".") continue;
-      walk(join4(dir, ent.name), depth + 1);
-    }
+function writeVisionMarkdownReport(args) {
+  const p2 = parse(args.imagePath);
+  const outPath = args.outPath ?? join3(p2.dir, `${p2.name || p2.base}.vision.md`);
+  const lines = [];
+  lines.push(`# UILint Vision Report`);
+  lines.push(``);
+  lines.push(`- Image: \`${p2.base}\``);
+  if (args.route) lines.push(`- Route: \`${args.route}\``);
+  if (typeof args.timestamp === "number") {
+    lines.push(`- Timestamp: \`${new Date(args.timestamp).toISOString()}\``);
+  }
+  if (args.visionModel) lines.push(`- Model: \`${args.visionModel}\``);
+  if (args.baseUrl) lines.push(`- Ollama baseUrl: \`${args.baseUrl}\``);
+  if (typeof args.analysisTimeMs === "number")
+    lines.push(`- Analysis time: \`${args.analysisTimeMs}ms\``);
+  lines.push(`- Generated: \`${(/* @__PURE__ */ new Date()).toISOString()}\``);
+  lines.push(``);
+  if (args.metadata && Object.keys(args.metadata).length > 0) {
+    lines.push(`## Metadata`);
+    lines.push(``);
+    lines.push("```json");
+    lines.push(JSON.stringify(args.metadata, null, 2));
+    lines.push("```");
+    lines.push(``);
   }
-  walk(rootDir, 0);
-  return results;
+  lines.push(`## Prompt`);
+  lines.push(``);
+  lines.push("```text");
+  lines.push((args.prompt ?? "").trim());
+  lines.push("```");
+  lines.push(``);
+  lines.push(`## Raw Response`);
+  lines.push(``);
+  lines.push("```text");
+  lines.push((args.rawResponse ?? "").trim());
+  lines.push("```");
+  lines.push(``);
+  const content = lines.join("\n");
+  mkdirSync3(dirname5(outPath), { recursive: true });
+  writeFileSync3(outPath, content, "utf-8");
+  return { outPath, content };
 }
 
-// src/utils/package-detect.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5, relative } from "path";
-var DEFAULT_IGNORE_DIRS3 = /* @__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);
+// src/commands/serve.ts
+function pickAppRoot(params) {
+  const { cwd, workspaceRoot } = params;
+  if (detectNextAppRouter(cwd)) return cwd;
+  const matches = findNextAppRouterProjects(workspaceRoot, { maxDepth: 5 });
+  if (matches.length === 0) return cwd;
+  if (matches.length === 1) return matches[0].projectPath;
+  const containing = matches.find(
+    (m) => cwd === m.projectPath || cwd.startsWith(m.projectPath + "/")
+  );
+  if (containing) return containing.projectPath;
+  return matches[0].projectPath;
 }
-function isTypeScriptPackage(dir, pkgJson) {
-  if (existsSync6(join5(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") && existsSync6(join5(dir, configFile))) {
-      return true;
-    }
+var cache = /* @__PURE__ */ new Map();
+var eslintInstances = /* @__PURE__ */ new Map();
+var visionAnalyzer = null;
+function getVisionAnalyzerInstance() {
+  if (!visionAnalyzer) {
+    visionAnalyzer = getCoreVisionAnalyzer();
   }
-  return false;
+  return visionAnalyzer;
 }
-function hasEslintConfig(dir) {
-  for (const file of ESLINT_CONFIG_FILES) {
-    if (existsSync6(join5(dir, file))) {
-      return true;
-    }
-  }
-  try {
-    const pkgPath = join5(dir, "package.json");
-    if (existsSync6(pkgPath)) {
-      const pkg = JSON.parse(readFileSync3(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_DIRS3;
-  const results = [];
-  const visited = /* @__PURE__ */ new Set();
-  function processPackage(dir, isRoot) {
-    const pkgPath = join5(dir, "package.json");
-    if (!existsSync6(pkgPath)) return null;
-    try {
-      const pkg = JSON.parse(readFileSync3(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 = readdirSync3(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(join5(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);
-  });
-}
-function formatPackageOption(pkg) {
-  const hints = [];
-  if (pkg.isRoot) hints.push("workspace root");
-  if (pkg.isFrontend) hints.push("frontend");
-  if (pkg.hasEslintConfig) hints.push("has ESLint config");
-  return {
-    value: pkg.path,
-    label: pkg.displayPath === "." ? pkg.name : `${pkg.name} (${pkg.displayPath})`,
-    hint: hints.length > 0 ? hints.join(", ") : void 0
-  };
-}
-
-// src/utils/package-manager.ts
-import { existsSync as existsSync7 } from "fs";
-import { spawn } from "child_process";
-import { dirname as dirname5, join as join6 } from "path";
-function detectPackageManager(projectPath) {
-  let dir = projectPath;
-  for (; ; ) {
-    if (existsSync7(join6(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync7(join6(dir, "pnpm-workspace.yaml"))) return "pnpm";
-    if (existsSync7(join6(dir, "yarn.lock"))) return "yarn";
-    if (existsSync7(join6(dir, "bun.lockb"))) return "bun";
-    if (existsSync7(join6(dir, "bun.lock"))) return "bun";
-    if (existsSync7(join6(dir, "package-lock.json"))) return "npm";
-    const parent = dirname5(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return "npm";
-}
-function spawnAsync(command, args, cwd) {
-  return new Promise((resolve7, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: "inherit",
-      shell: process.platform === "win32"
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve7();
-      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 existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7, relative as relative2, dirname as dirname6 } from "path";
-import { parseExpression, parseModule, generateCode } from "magicast";
-import { findWorkspaceRoot as findWorkspaceRoot4 } from "uilint-core/node";
-var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
-function findEslintConfigFile(projectPath) {
-  for (const ext of CONFIG_EXTENSIONS) {
-    const configPath = join7(projectPath, `eslint.config${ext}`);
-    if (existsSync8(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(
-    (p2) => p2 && (p2.type === "SpreadElement" || p2.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(program3, name) {
-    if (!program3 || program3.type !== "Program") return null;
-    for (const stmt of program3.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 program2 = mod?.$ast;
-  if (program2 && program2.type === "Program") {
-    for (const stmt of program2.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: program2 };
-      }
-      if (decl.type === "CallExpression" && isIdentifier(decl.callee, "defineConfig") && unwrapExpression2(decl.arguments?.[0])?.type === "ArrayExpression") {
-        return {
-          kind: "esm",
-          arrayExpr: unwrapExpression2(decl.arguments?.[0]),
-          program: program2
-        };
-      }
-      if (decl.type === "Identifier" && typeof decl.name === "string") {
-        const resolved = resolveTopLevelIdentifierToArrayExpr(
-          program2,
-          decl.name
-        );
-        if (resolved) return { kind: "esm", arrayExpr: resolved, program: program2 };
-      }
-      break;
-    }
-  }
-  if (!program2 || program2.type !== "Program") return null;
-  for (const stmt of program2.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: program2 };
-    }
-    if (right?.type === "CallExpression" && isIdentifier(right.callee, "defineConfig") && right.arguments?.[0]?.type === "ArrayExpression") {
-      return { kind: "cjs", arrayExpr: right.arguments[0], program: program2 };
-    }
-    if (right?.type === "Identifier" && typeof right.name === "string") {
-      const resolved = resolveTopLevelIdentifierToArrayExpr(
-        program2,
-        right.name
-      );
-      if (resolved) return { kind: "cjs", arrayExpr: resolved, program: program2 };
-    }
-  }
-  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(program2) {
-  const names = /* @__PURE__ */ new Set();
-  if (!program2 || program2.type !== "Program") return names;
-  for (const stmt of program2.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 = dirname6(configPath);
-  const rulesDir = join7(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(program2, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
-  const importNames = /* @__PURE__ */ new Map();
-  let changed = false;
-  if (!program2 || program2.type !== "Program") {
-    return { importNames, changed };
-  }
-  const configDir = dirname6(configPath);
-  const rulesDir = join7(rulesRoot, ".uilint", "rules");
-  const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
-  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
-  const used = collectTopLevelBindings(program2);
-  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 = program2.body?.[0];
-      if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
-        insertAt = 1;
-      }
-      program2.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 = readFileSync4(configPath, "utf-8");
-  const isCommonJS = configPath.endsWith(".cjs");
-  const ast = getUilintEslintConfigInfoFromSourceAst(original);
-  if ("error" in ast) {
-    return {
-      configFile: configFilename,
-      modified: false,
-      missingRuleIds: [],
-      configured: false,
-      error: ast.error
-    };
-  }
-  const { info, mod, arrayExpr, kind } = ast;
-  const configuredIds = info.configuredRuleIds;
-  const missingRules = getMissingSelectedRules(
-    opts.selectedRules,
-    configuredIds
-  );
-  const rulesToUpdate = getRulesNeedingUpdate(
-    opts.selectedRules,
-    configuredIds,
-    arrayExpr
-  );
-  let rulesToApply = [];
-  if (!info.configured) {
-    rulesToApply = opts.selectedRules;
-  } else {
-    rulesToApply = [...missingRules, ...rulesToUpdate];
-    if (missingRules.length > 0 && !opts.force) {
-      const ok = await opts.confirmAddMissingRules?.(
-        configFilename,
-        missingRules
-      );
-      if (!ok) {
-        return {
-          configFile: configFilename,
-          modified: false,
-          missingRuleIds: missingRules.map((r) => r.id),
-          configured: true
-        };
-      }
-    }
-  }
-  if (rulesToApply.length === 0) {
-    return {
-      configFile: configFilename,
-      modified: false,
-      missingRuleIds: missingRules.map((r) => r.id),
-      configured: info.configured
-    };
-  }
-  let modifiedAst = false;
-  const localRulesDir = join7(opts.projectPath, ".uilint", "rules");
-  const workspaceRoot = findWorkspaceRoot4(opts.projectPath);
-  const workspaceRulesDir = join7(workspaceRoot, ".uilint", "rules");
-  const rulesRoot = existsSync8(localRulesDir) ? opts.projectPath : workspaceRoot;
-  let fileExtension = ".js";
-  if (rulesToApply.length > 0) {
-    const firstRulePath = join7(
-      rulesRoot,
-      ".uilint",
-      "rules",
-      `${rulesToApply[0].id}.ts`
-    );
-    if (existsSync8(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) {
-    writeFileSync3(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 analyze2(projectPath = process.cwd()) {
-  const workspaceRoot = findWorkspaceRoot5(projectPath);
-  const packageManager = detectPackageManager(projectPath);
-  const cursorDir = join8(projectPath, ".cursor");
-  const cursorDirExists = existsSync9(cursorDir);
-  const styleguidePath = join8(projectPath, ".uilint", "styleguide.md");
-  const styleguideExists = existsSync9(styleguidePath);
-  const commandsDir = join8(cursorDir, "commands");
-  const genstyleguideExists = existsSync9(join8(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 = readFileSync5(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/plan.ts
-import { join as join11 } from "path";
-import { createRequire as createRequire2 } from "module";
-
-// src/commands/install/constants.ts
-var GENSTYLEGUIDE_COMMAND_MD = `# React Style Guide Generator
-
-Analyze the React UI codebase to produce a **prescriptive, semantic** style guide. Focus on consistency, intent, and relationships\u2014not specific values.
-
-## Philosophy
-
-1. **Identify the intended architecture** from the best patterns in use
-2. **Prescribe semantic rules** \u2014 about consistency and relationships, not pixels
-3. **Stay general** \u2014 "primary buttons should be visually consistent" not "buttons use px-4"
-4. **Focus on intent** \u2014 what should FEEL the same, not what values to use
-
-## Analysis Steps
-
-### 1. Detect the Stack
-- Framework: Next.js (App Router? Pages?), Vite, CRA
-- Component system: shadcn, MUI, Chakra, Radix, custom
-- Styling: Tailwind, CSS Modules, styled-components
-- Forms: react-hook-form, Formik, native
-- State: React context, Zustand, Redux, Jotai
-
-### 2. Identify Best Patterns
-Examine the **best-written** components. Look at:
-- \`components/ui/*\` \u2014 the design system
-- Recently modified files \u2014 current standards
-- Shared layouts \u2014 structural patterns
-
-### 3. Infer Visual Hierarchy & Intent
-Understand the design language:
-- What distinguishes primary vs secondary actions?
-- How is visual hierarchy established?
-- What creates consistency across similar elements?
-
-## Output Format
-
-Generate at \`<nextjs app root>/.uilint/styleguide.md\`:
-\`\`\`yaml
-# Stack
-framework: 
-styling: 
-components: 
-component_path: 
-forms: 
-
-# Component Usage (MUST use these)
-use:
-  buttons: 
-  inputs: 
-  modals: 
-  cards: 
-  feedback: 
-  icons: 
-  links: 
-
-# Semantic Rules (consistency & relationships)
-semantics:
-  hierarchy:
-    - <e.g., "primary actions must be visually distinct from secondary">
-    - <e.g., "destructive actions should be visually cautionary">
-    - <e.g., "page titles should be visually heavier than section titles">
-  consistency:
-    - <e.g., "all primary buttons should share the same visual weight">
-    - <e.g., "form inputs should have uniform height and padding">
-    - <e.g., "card padding should be consistent across the app">
-    - <e.g., "interactive elements should have consistent hover/focus states">
-  spacing:
-    - <e.g., "use the spacing scale \u2014 no arbitrary values">
-    - <e.g., "related elements should be closer than unrelated">
-    - <e.g., "section spacing should be larger than element spacing">
-  layout:
-    - <e.g., "use gap for sibling spacing, not margin">
-    - <e.g., "containers should have consistent max-width and padding">
-
-# Patterns (structural, not values)
-patterns:
-  forms: <e.g., "FormField + Controller + zod schema">
-  conditionals: <e.g., "cn() for class merging">
-  loading: <e.g., "Skeleton for content, Spinner for actions">
-  errors: <e.g., "ErrorBoundary at route, inline for forms">
-  responsive: <e.g., "mobile-first, standard breakpoints only">
-
-# Component Authoring
-authoring:
-  - <e.g., "forwardRef for interactive components">
-  - <e.g., "variants via CVA or component props, not className overrides">
-  - <e.g., "extract when used 2+ times">
-  - <e.g., "'use client' only when needed">
-
-# Forbidden
-forbidden:
-  - <e.g., "inline style={{}}">
-  - <e.g., "raw HTML elements when component exists">
-  - <e.g., "arbitrary values \u2014 use scale">
-  - <e.g., "className overrides that break visual consistency">
-  - <e.g., "one-off spacing that doesn't match siblings">
-
-# Legacy (if migration in progress)
-legacy:
-  - <e.g., "old: CSS modules \u2192 new: Tailwind">
-  - <e.g., "old: Formik \u2192 new: react-hook-form">
-
-# Conventions
-conventions:
-  - 
-  - 
-  - 
-\`\`\`
-
-## Rules
-
-- **Semantic over specific**: "consistent padding" not "p-4"
-- **Relationships over absolutes**: "heavier than" not "font-bold"
-- **Intent over implementation**: "visually distinct" not "blue background"
-- **Prescriptive**: Define target state, not current state
-- **Terse**: No prose. Fragments and short phrases only.
-- **Actionable**: Every rule should be human-verifiable
-- **Omit if N/A**: Skip sections that don't apply
-- **Max 5 items** per section \u2014 highest impact only
-`;
-
-// src/utils/skill-loader.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync2, existsSync as existsSync10 } from "fs";
-import { join as join9, dirname as dirname7, relative as relative3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname7(__filename);
-function getSkillsDir() {
-  const devPath = join9(__dirname, "..", "..", "skills");
-  const prodPath = join9(__dirname, "..", "skills");
-  if (existsSync10(devPath)) {
-    return devPath;
-  }
-  if (existsSync10(prodPath)) {
-    return prodPath;
-  }
-  throw new Error(
-    "Could not find skills directory. This is a bug in uilint installation."
-  );
-}
-function collectFiles(dir, baseDir) {
-  const files = [];
-  const entries = readdirSync4(dir);
-  for (const entry of entries) {
-    const fullPath = join9(dir, entry);
-    const stat = statSync2(fullPath);
-    if (stat.isDirectory()) {
-      files.push(...collectFiles(fullPath, baseDir));
-    } else if (stat.isFile()) {
-      const relativePath = relative3(baseDir, fullPath);
-      const content = readFileSync6(fullPath, "utf-8");
-      files.push({ relativePath, content });
-    }
-  }
-  return files;
-}
-function loadSkill(name) {
-  const skillsDir = getSkillsDir();
-  const skillDir = join9(skillsDir, name);
-  if (!existsSync10(skillDir)) {
-    throw new Error(`Skill "${name}" not found in ${skillsDir}`);
-  }
-  const skillMdPath = join9(skillDir, "SKILL.md");
-  if (!existsSync10(skillMdPath)) {
-    throw new Error(`Skill "${name}" is missing SKILL.md`);
-  }
-  const files = collectFiles(skillDir, skillDir);
-  return { name, files };
-}
-
-// src/utils/rule-loader.ts
-import { readFileSync as readFileSync7, existsSync as existsSync11 } from "fs";
-import { join as join10, dirname as dirname8 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { createRequire } from "module";
-var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname2 = dirname8(__filename2);
-var require2 = createRequire(import.meta.url);
-function findNodeModulesPackageRoot(pkgName, startDir) {
-  let dir = startDir;
-  while (true) {
-    const candidate = join10(dir, "node_modules", pkgName);
-    if (existsSync11(join10(candidate, "package.json"))) return candidate;
-    const parent = dirname8(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function getUilintEslintPackageRoot() {
-  const fromCwd = findNodeModulesPackageRoot("uilint-eslint", process.cwd());
-  if (fromCwd) return fromCwd;
-  const fromHere = findNodeModulesPackageRoot("uilint-eslint", __dirname2);
-  if (fromHere) return fromHere;
-  try {
-    const entry = require2.resolve("uilint-eslint");
-    const entryDir = dirname8(entry);
-    return dirname8(entryDir);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    throw new Error(
-      `Unable to locate uilint-eslint in node_modules (searched upwards from cwd and uilint's install path).
-Resolver error: ${msg}
-Fix: ensure uilint-eslint is installed in the target project (or workspace) and try again.`
-    );
-  }
-}
-function getUilintEslintSrcDir() {
-  const devPath = join10(
-    __dirname2,
-    "..",
-    "..",
-    "..",
-    "..",
-    "uilint-eslint",
-    "src"
-  );
-  if (existsSync11(devPath)) return devPath;
-  const pkgRoot = getUilintEslintPackageRoot();
-  const srcPath = join10(pkgRoot, "src");
-  if (existsSync11(srcPath)) return srcPath;
-  throw new Error(
-    'Could not find uilint-eslint "src/" directory. If you are using a published install of uilint-eslint, ensure it includes source files, or run a JS-only rules install.'
-  );
-}
-function getUilintEslintDistDir() {
-  const devPath = join10(
-    __dirname2,
-    "..",
-    "..",
-    "..",
-    "..",
-    "uilint-eslint",
-    "dist"
-  );
-  if (existsSync11(devPath)) return devPath;
-  const pkgRoot = getUilintEslintPackageRoot();
-  const distPath = join10(pkgRoot, "dist");
-  if (existsSync11(distPath)) return distPath;
-  throw new Error(
-    'Could not find uilint-eslint "dist/" directory. This is a bug in uilint installation.'
-  );
-}
-function transformRuleContent(content) {
-  let transformed = content;
-  transformed = transformed.replace(
-    /import\s+{\s*createRule\s*}\s+from\s+["']\.\.\/utils\/create-rule\.js["'];?/g,
-    'import { createRule } from "uilint-eslint";'
-  );
-  transformed = transformed.replace(
-    /import\s+createRule\s+from\s+["']\.\.\/utils\/create-rule\.js["'];?/g,
-    'import { createRule } from "uilint-eslint";'
-  );
-  transformed = transformed.replace(
-    /import\s+{([^}]+)}\s+from\s+["']\.\.\/utils\/([^"']+)\.js["'];?/g,
-    (match, imports, utilFile) => {
-      const utilsFromPackage = ["cache", "styleguide-loader", "import-graph"];
-      if (utilsFromPackage.includes(utilFile)) {
-        return `import {${imports}} from "uilint-eslint";`;
-      }
-      return match;
-    }
-  );
-  return transformed;
-}
-function loadRule(ruleId, options = { typescript: true }) {
-  const { typescript } = options;
-  const extension = typescript ? ".ts" : ".js";
-  if (typescript) {
-    const rulesDir = join10(getUilintEslintSrcDir(), "rules");
-    const implPath = join10(rulesDir, `${ruleId}.ts`);
-    const testPath = join10(rulesDir, `${ruleId}.test.ts`);
-    if (!existsSync11(implPath)) {
-      throw new Error(`Rule "${ruleId}" not found at ${implPath}`);
-    }
-    const rawContent = readFileSync7(implPath, "utf-8");
-    const transformedContent = transformRuleContent(rawContent);
-    const implementation = {
-      relativePath: `${ruleId}.ts`,
-      content: transformedContent
-    };
-    const test = existsSync11(testPath) ? {
-      relativePath: `${ruleId}.test.ts`,
-      content: transformRuleContent(readFileSync7(testPath, "utf-8"))
-    } : void 0;
-    return {
-      ruleId,
-      implementation,
-      test
-    };
-  } else {
-    const rulesDir = join10(getUilintEslintDistDir(), "rules");
-    const implPath = join10(rulesDir, `${ruleId}.js`);
-    if (!existsSync11(implPath)) {
-      throw new Error(
-        `Rule "${ruleId}" not found at ${implPath}. For JavaScript-only projects, uilint-eslint must be built to include compiled rule files in dist/rules/. If you're developing uilint-eslint, run 'pnpm build' in packages/uilint-eslint. If you're using a published package, ensure it includes the dist/ directory.`
-      );
-    }
-    const content = readFileSync7(implPath, "utf-8");
-    const implementation = {
-      relativePath: `${ruleId}.js`,
-      content
-    };
-    return {
-      ruleId,
-      implementation
-    };
-  }
-}
-function loadSelectedRules(ruleIds, options = { typescript: true }) {
-  return ruleIds.map((id) => loadRule(id, options));
-}
-
-// src/commands/install/plan.ts
-var require3 = createRequire2(import.meta.url);
-function getSelfDependencyVersionRange(pkgName) {
-  try {
-    const pkgJson = require3("uilint/package.json");
-    const deps = pkgJson?.dependencies;
-    const optDeps = pkgJson?.optionalDependencies;
-    const peerDeps = pkgJson?.peerDependencies;
-    const v = deps?.[pkgName] ?? optDeps?.[pkgName] ?? peerDeps?.[pkgName];
-    return typeof v === "string" ? v : null;
-  } catch {
-    return null;
-  }
-}
-function toInstallSpecifier(pkgName) {
-  const range = getSelfDependencyVersionRange(pkgName);
-  if (!range) return pkgName;
-  if (range.startsWith("workspace:")) return pkgName;
-  if (range.startsWith("file:")) return pkgName;
-  if (range.startsWith("link:")) return pkgName;
-  return `${pkgName}@${range}`;
-}
-function createPlan(state, choices, options = {}) {
-  const actions = [];
-  const dependencies = [];
-  const { force = false } = options;
-  const { items } = choices;
-  const needsCursorDir = items.includes("genstyleguide") || items.includes("skill");
-  if (needsCursorDir && !state.cursorDir.exists) {
-    actions.push({
-      type: "create_directory",
-      path: state.cursorDir.path
-    });
-  }
-  if (items.includes("genstyleguide")) {
-    const commandsDir = join11(state.cursorDir.path, "commands");
-    actions.push({
-      type: "create_directory",
-      path: commandsDir
-    });
-    actions.push({
-      type: "create_file",
-      path: join11(commandsDir, "genstyleguide.md"),
-      content: GENSTYLEGUIDE_COMMAND_MD
-    });
-  }
-  if (items.includes("skill")) {
-    const skillsDir = join11(state.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 {
-    }
-  }
-  if (items.includes("next") && choices.next) {
-    const { projectPath, detection } = choices.next;
-    actions.push({
-      type: "install_next_routes",
-      projectPath,
-      appRoot: detection.appRoot
-    });
-    dependencies.push({
-      packagePath: projectPath,
-      packageManager: state.packageManager,
-      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
-    });
-    actions.push({
-      type: "inject_react",
-      projectPath,
-      appRoot: detection.appRoot
-    });
-    actions.push({
-      type: "inject_next_config",
-      projectPath
-    });
-  }
-  if (items.includes("vite") && choices.vite) {
-    const { projectPath, detection } = choices.vite;
-    dependencies.push({
-      packagePath: projectPath,
-      packageManager: state.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
-    });
-  }
-  if (items.includes("eslint") && choices.eslint) {
-    const { packagePaths, selectedRules } = choices.eslint;
-    for (const pkgPath of packagePaths) {
-      const pkgInfo = state.packages.find((p2) => p2.path === pkgPath);
-      const rulesDir = join11(pkgPath, ".uilint", "rules");
-      actions.push({
-        type: "create_directory",
-        path: rulesDir
-      });
-      const isTypeScript = pkgInfo?.isTypeScript ?? true;
-      const ruleFiles = loadSelectedRules(
-        selectedRules.map((r) => r.id),
-        {
-          typescript: isTypeScript
-        }
-      );
-      for (const ruleFile of ruleFiles) {
-        actions.push({
-          type: "create_file",
-          path: join11(rulesDir, ruleFile.implementation.relativePath),
-          content: ruleFile.implementation.content
-        });
-        if (ruleFile.test && isTypeScript) {
-          actions.push({
-            type: "create_file",
-            path: join11(rulesDir, ruleFile.test.relativePath),
-            content: ruleFile.test.content
-          });
-        }
-      }
-      dependencies.push({
-        packagePath: pkgPath,
-        packageManager: state.packageManager,
-        packages: [toInstallSpecifier("uilint-eslint"), "typescript-eslint"]
-      });
-      if (pkgInfo?.eslintConfigPath) {
-        actions.push({
-          type: "inject_eslint",
-          packagePath: pkgPath,
-          configPath: pkgInfo.eslintConfigPath,
-          rules: selectedRules,
-          hasExistingRules: pkgInfo.hasUilintRules
-        });
-      }
-    }
-    const gitignorePath = join11(state.workspaceRoot, ".gitignore");
-    actions.push({
-      type: "append_to_file",
-      path: gitignorePath,
-      content: "\n# UILint cache\n.uilint/.cache\n",
-      ifNotContains: ".uilint/.cache"
-    });
-  }
-  return { actions, dependencies };
-}
-
-// src/commands/install/execute.ts
-import {
-  existsSync as existsSync16,
-  mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync11,
-  unlinkSync,
-  chmodSync
-} from "fs";
-import { dirname as dirname9 } from "path";
-
-// src/utils/react-inject.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
-import { join as join12 } from "path";
-import { parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
-function getDefaultCandidates(projectPath, appRoot) {
-  const viteMainCandidates = [
-    join12(appRoot, "main.tsx"),
-    join12(appRoot, "main.jsx"),
-    join12(appRoot, "main.ts"),
-    join12(appRoot, "main.js")
-  ];
-  const existingViteMain = viteMainCandidates.filter(
-    (rel) => existsSync12(join12(projectPath, rel))
-  );
-  if (existingViteMain.length > 0) return existingViteMain;
-  const viteAppCandidates = [join12(appRoot, "App.tsx"), join12(appRoot, "App.jsx")];
-  const existingViteApp = viteAppCandidates.filter(
-    (rel) => existsSync12(join12(projectPath, rel))
-  );
-  if (existingViteApp.length > 0) return existingViteApp;
-  const layoutCandidates = [
-    join12(appRoot, "layout.tsx"),
-    join12(appRoot, "layout.jsx"),
-    join12(appRoot, "layout.ts"),
-    join12(appRoot, "layout.js")
-  ];
-  const existingLayouts = layoutCandidates.filter(
-    (rel) => existsSync12(join12(projectPath, rel))
-  );
-  if (existingLayouts.length > 0) {
-    return existingLayouts;
-  }
-  const pageCandidates = [join12(appRoot, "page.tsx"), join12(appRoot, "page.jsx")];
-  return pageCandidates.filter((rel) => existsSync12(join12(projectPath, rel)));
-}
-function isUseClientDirective(stmt) {
-  return stmt?.type === "ExpressionStatement" && stmt.expression?.type === "StringLiteral" && stmt.expression.value === "use client";
-}
-function findImportDeclaration(program2, from) {
-  if (!program2 || program2.type !== "Program") return null;
-  for (const stmt of program2.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(program2) {
-  let found = false;
-  walkAst(program2, (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(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  if (hasUILintDevtoolsJsx(program2)) 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(program2, (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(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  if (hasUILintDevtoolsJsx(program2)) return { changed: false };
-  let added = false;
-  walkAst(program2, (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(program2, from) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  const existing = findImportDeclaration(program2, from);
-  if (existing) return { changed: false };
-  const importDecl = parseModule2(`import "${from}";`).$ast.body?.[0];
-  if (!importDecl) return { changed: false };
-  const body = program2.body ?? [];
-  let insertAt = 0;
-  while (insertAt < body.length && isUseClientDirective(body[insertAt])) {
-    insertAt++;
-  }
-  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
-    insertAt++;
-  }
-  program2.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 = join12(opts.projectPath, chosen);
-  const original = readFileSync8(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 program2 = mod.$ast;
-  const hasDevtoolsImport = !!findImportDeclaration(program2, "uilint-react/devtools");
-  const hasOldImport = !!findImportDeclaration(program2, "uilint-react");
-  const alreadyConfigured = (hasDevtoolsImport || hasOldImport) && hasUILintDevtoolsJsx(program2);
-  let changed = false;
-  const importRes = ensureSideEffectImport(program2, "uilint-react/devtools");
-  if (importRes.changed) changed = true;
-  const mode = opts.mode ?? "next";
-  const addRes = mode === "vite" ? addDevtoolsElementVite(program2) : addDevtoolsElementNextJs(program2);
-  if (addRes.changed) changed = true;
-  const updated = changed ? generateCode2(mod).code : original;
-  const modified = updated !== original;
-  if (modified) {
-    writeFileSync4(absTarget, updated, "utf-8");
-  }
-  return {
-    targetFile: chosen,
-    modified,
-    alreadyConfigured: alreadyConfigured && !modified
-  };
-}
-
-// src/utils/next-config-inject.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
-import { join as join13 } 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 = join13(projectPath, `next.config${ext}`);
-    if (existsSync13(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(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  const existing = (program2.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 = program2.body ?? [];
-  let insertAt = 0;
-  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
-    insertAt++;
-  }
-  program2.body.splice(insertAt, 0, importDecl);
-  return { changed: true };
-}
-function ensureCjsWithJsxLocRequire(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  for (const stmt of program2.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((p2) => {
-            if (p2?.type !== "ObjectProperty" && p2?.type !== "Property") return false;
-            return isIdentifier2(p2.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 };
-  program2.body.unshift(reqDecl);
-  return { changed: true };
-}
-function wrapEsmExportDefault(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  const exportDecl = (program2.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(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  for (const stmt of program2.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 = readFileSync9(configPath, "utf-8");
-  let mod;
-  try {
-    mod = parseModule3(original);
-  } catch {
-    return { configFile: configFilename, modified: false };
-  }
-  const program2 = mod.$ast;
-  const isCjs = configPath.endsWith(".cjs");
-  let changed = false;
-  if (isCjs) {
-    const reqRes = ensureCjsWithJsxLocRequire(program2);
-    if (reqRes.changed) changed = true;
-    const wrapRes = wrapCjsModuleExports(program2);
-    if (wrapRes.changed) changed = true;
-  } else {
-    const impRes = ensureEsmWithJsxLocImport(program2);
-    if (impRes.changed) changed = true;
-    const wrapRes = wrapEsmExportDefault(program2);
-    if (wrapRes.changed) changed = true;
-  }
-  const updated = changed ? generateCode3(mod).code : original;
-  if (updated !== original) {
-    writeFileSync5(configPath, updated, "utf-8");
-    return { configFile: configFilename, modified: true };
-  }
-  return { configFile: configFilename, modified: false };
-}
-
-// src/utils/vite-config-inject.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { join as join14 } 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 = join14(projectPath, `vite.config${ext}`);
-    if (existsSync14(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 program2 = mod?.$ast;
-  if (!program2 || program2.type !== "Program") return null;
-  for (const stmt of program2.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: program2 };
-    }
-    if (decl.type === "CallExpression" && isIdentifier3(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ObjectExpression") {
-      return {
-        kind: "esm",
-        objExpr: unwrapExpression(decl.arguments?.[0]),
-        program: program2
-      };
-    }
-    break;
-  }
-  for (const stmt of program2.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: program2 };
-    }
-    if (right?.type === "CallExpression" && isIdentifier3(right.callee, "defineConfig") && unwrapExpression(right.arguments?.[0])?.type === "ObjectExpression") {
-      return {
-        kind: "cjs",
-        objExpr: unwrapExpression(right.arguments?.[0]),
-        program: program2
-      };
-    }
-  }
-  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(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  const existing = (program2.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 = program2.body ?? [];
-  let insertAt = 0;
-  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
-    insertAt++;
-  }
-  program2.body.splice(insertAt, 0, importDecl);
-  return { changed: true };
-}
-function ensureCjsJsxLocRequire(program2) {
-  if (!program2 || program2.type !== "Program") return { changed: false };
-  for (const stmt of program2.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((p2) => {
-            if (p2?.type !== "ObjectProperty" && p2?.type !== "Property") return false;
-            return isIdentifier3(p2.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 };
-  program2.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((p2) => {
-      const k = p2?.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 = readFileSync10(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) {
-    writeFileSync6(configPath, updated, "utf-8");
-    return { configFile: configFilename, modified: true };
-  }
-  return { configFile: configFilename, modified: false };
-}
-
-// src/utils/next-routes.ts
-import { existsSync as existsSync15 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import { join as join15 } 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 (existsSync15(absPath) && !opts.force) return;
-  await writeFile(absPath, content, "utf-8");
-}
-async function installNextUILintRoutes(opts) {
-  const baseRel = join15(opts.appRoot, "api", ".uilint");
-  const baseAbs = join15(opts.projectPath, baseRel);
-  await mkdir(join15(baseAbs, "source"), { recursive: true });
-  await writeRouteFile(
-    join15(baseAbs, "source", "route.ts"),
-    join15(baseRel, "source", "route.ts"),
-    DEV_SOURCE_ROUTE_TS,
-    opts
-  );
-  await mkdir(join15(baseAbs, "screenshots"), { recursive: true });
-  await writeRouteFile(
-    join15(baseAbs, "screenshots", "route.ts"),
-    join15(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 (!existsSync16(action.path)) {
-          mkdirSync3(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 = dirname9(action.path);
-        if (!existsSync16(dir)) {
-          mkdirSync3(dir, { recursive: true });
-        }
-        writeFileSync7(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 (existsSync16(action.path)) {
-          try {
-            existing = JSON.parse(readFileSync11(action.path, "utf-8"));
-          } catch {
-          }
-        }
-        const merged = deepMerge(existing, action.merge);
-        const dir = dirname9(action.path);
-        if (!existsSync16(dir)) {
-          mkdirSync3(dir, { recursive: true });
-        }
-        writeFileSync7(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 (existsSync16(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 (existsSync16(action.path)) {
-          const content = readFileSync11(action.path, "utf-8");
-          if (action.ifNotContains && content.includes(action.ifNotContains)) {
-            return { action, success: true };
-          }
-          writeFileSync7(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/prompter.ts
-import { ruleRegistry } from "uilint-eslint";
-var cliPrompter = {
-  async selectInstallItems() {
-    return multiselect2({
-      message: "What would you like to install?",
-      options: [
-        {
-          value: "eslint",
-          label: "ESLint plugin",
-          hint: "Installs uilint-eslint and configures eslint.config.*"
-        },
-        {
-          value: "next",
-          label: "UI overlay",
-          hint: "Installs routes + devtools (Alt+Click to inspect)"
-        },
-        {
-          value: "vite",
-          label: "UI overlay (Vite)",
-          hint: "Installs jsx-loc-plugin + devtools (Alt+Click to inspect)"
-        },
-        {
-          value: "genstyleguide",
-          label: "/genstyleguide command",
-          hint: "Adds .cursor/commands/genstyleguide.md"
-        },
-        {
-          value: "skill",
-          label: "UI Consistency Agent Skill",
-          hint: "Cursor agent skill for generating ESLint rules from UI patterns"
-        }
-      ],
-      required: true,
-      initialValues: ["eslint", "next", "genstyleguide", "skill"]
-    });
-  },
-  async selectNextApp(apps) {
-    const chosen = await select2({
-      message: "Which Next.js App Router project should UILint install into?",
-      options: apps.map((app) => ({
-        value: app.projectPath,
-        label: app.projectPath
-      })),
-      initialValue: apps[0].projectPath
-    });
-    return apps.find((a) => a.projectPath === chosen) || apps[0];
-  },
-  async selectViteApp(apps) {
-    const chosen = await select2({
-      message: "Which Vite + React project should UILint install into?",
-      options: apps.map((app) => ({
-        value: app.projectPath,
-        label: app.projectPath
-      })),
-      initialValue: apps[0].projectPath
-    });
-    return apps.find((a) => a.projectPath === chosen) || apps[0];
-  },
-  async selectEslintPackages(packages) {
-    if (packages.length === 1) {
-      const confirmed = await confirm2({
-        message: `Install ESLint plugin in ${pc.cyan(
-          packages[0].displayPath
-        )}?`,
-        initialValue: true
-      });
-      return confirmed ? [packages[0].path] : [];
-    }
-    const initialValues = packages.filter((p2) => p2.isFrontend).map((p2) => p2.path).slice(0, 1);
-    return multiselect2({
-      message: "Which packages should have ESLint plugin installed?",
-      options: packages.map(formatPackageOption),
-      required: false,
-      initialValues: initialValues.length > 0 ? initialValues : [packages[0].path]
-    });
-  },
-  async selectEslintRules() {
-    const selectedRuleIds = await multiselect2({
-      message: "Which rules would you like to enable?",
-      options: ruleRegistry.map((rule) => ({
-        value: rule.id,
-        label: rule.name,
-        hint: rule.description
-      })),
-      required: false,
-      initialValues: ruleRegistry.filter(
-        (r) => r.category === "static" || !r.requiresStyleguide
-      ).map((r) => r.id)
-    });
-    return ruleRegistry.filter(
-      (r) => selectedRuleIds.includes(r.id)
-    );
-  },
-  async selectEslintRuleSeverity() {
-    return select2({
-      message: "How strict should the selected ESLint rules be?",
-      options: [
-        {
-          value: "warn",
-          label: "Warn (recommended)",
-          hint: "Safer default while you dial in your styleguide + rules"
-        },
-        {
-          value: "error",
-          label: "Error (strict)",
-          hint: "Make selected rules fail CI"
-        },
-        {
-          value: "defaults",
-          label: "Use rule defaults",
-          hint: "Some rules are warn, some are error (as defined by uilint-eslint)"
-        }
-      ],
-      initialValue: "warn"
-    });
-  },
-  async confirmCustomizeRuleOptions() {
-    return confirm2({
-      message: "Customize individual rule options? (spacing scale, thresholds, etc.)",
-      initialValue: false
-    });
-  },
-  async configureRuleOptions(rule) {
-    if (!rule.optionSchema || rule.optionSchema.fields.length === 0) {
-      return void 0;
-    }
-    const options = {};
-    for (const field of rule.optionSchema.fields) {
-      const value = await promptForField(field, rule.name);
-      if (value !== void 0) {
-        options[field.key] = value;
-      }
-    }
-    return Object.keys(options).length > 0 ? options : void 0;
-  }
-};
-async function promptForField(field, ruleName) {
-  const message = `${pc.cyan(ruleName)} - ${field.label}`;
-  switch (field.type) {
-    case "text": {
-      const result = await text2({
-        message,
-        placeholder: field.placeholder,
-        defaultValue: typeof field.defaultValue === "string" ? field.defaultValue : Array.isArray(field.defaultValue) ? field.defaultValue.join(", ") : String(field.defaultValue)
-      });
-      if (field.key === "scale" && typeof result === "string") {
-        const scale = result.split(",").map((s) => parseFloat(s.trim())).filter((n) => !isNaN(n));
-        return scale.length > 0 ? scale : field.defaultValue;
-      }
-      return result || field.defaultValue;
-    }
-    case "number": {
-      const result = await text2({
-        message,
-        placeholder: field.placeholder || String(field.defaultValue),
-        defaultValue: String(field.defaultValue)
-      });
-      const num = parseFloat(result);
-      return isNaN(num) ? field.defaultValue : num;
-    }
-    case "boolean": {
-      return await confirm2({
-        message,
-        initialValue: Boolean(field.defaultValue)
-      });
-    }
-    case "select": {
-      if (!field.options) {
-        return field.defaultValue;
-      }
-      const stringOptions = field.options.map(
-        (opt) => ({
-          value: String(opt.value),
-          label: opt.label
-        })
-      );
-      const result = await select2({
-        message,
-        options: stringOptions,
-        initialValue: String(field.defaultValue)
-      });
-      const originalOpt = field.options.find(
-        (opt) => String(opt.value) === result
-      );
-      return originalOpt?.value ?? result;
-    }
-    case "multiselect": {
-      if (!field.options) {
-        return field.defaultValue;
-      }
-      const stringOptions = field.options.map(
-        (opt) => ({
-          value: String(opt.value),
-          label: opt.label
-        })
-      );
-      const result = await multiselect2({
-        message,
-        options: stringOptions,
-        initialValues: Array.isArray(field.defaultValue) ? field.defaultValue.map((v) => String(v)) : [String(field.defaultValue)]
-      });
-      return result.map((selected) => {
-        const originalOpt = field.options.find(
-          (opt) => String(opt.value) === selected
-        );
-        return originalOpt?.value ?? selected;
-      });
-    }
-    default:
-      return field.defaultValue;
-  }
-}
-async function gatherChoices(state, options, prompter) {
-  let items;
-  const hasExplicitFlags = options.genstyleguide !== void 0 || options.skill !== void 0 || options.routes !== void 0 || options.react !== void 0;
-  if (hasExplicitFlags || options.eslint) {
-    items = [];
-    if (options.genstyleguide) items.push("genstyleguide");
-    if (options.skill) items.push("skill");
-    if (options.routes || options.react) items.push("next");
-    if (options.eslint) items.push("eslint");
-  } else {
-    items = await prompter.selectInstallItems();
-  }
-  let nextChoices;
-  if (items.includes("next")) {
-    if (state.nextApps.length === 0) {
-      throw new Error(
-        "Could not find a Next.js App Router app root (expected app/ or src/app/). Run this from your Next.js project root."
-      );
-    } else if (state.nextApps.length === 1) {
-      nextChoices = {
-        projectPath: state.nextApps[0].projectPath,
-        detection: state.nextApps[0].detection
-      };
-    } else {
-      const selected = await prompter.selectNextApp(state.nextApps);
-      nextChoices = {
-        projectPath: selected.projectPath,
-        detection: selected.detection
-      };
-    }
-  }
-  let viteChoices;
-  if (items.includes("vite")) {
-    if (state.viteApps.length === 0) {
-      throw new Error(
-        "Could not find a Vite + React project (expected vite.config.* + react deps). Run this from your Vite project root."
-      );
-    } else if (state.viteApps.length === 1) {
-      viteChoices = {
-        projectPath: state.viteApps[0].projectPath,
-        detection: state.viteApps[0].detection
-      };
-    } else {
-      const selected = await prompter.selectViteApp(state.viteApps);
-      viteChoices = {
-        projectPath: selected.projectPath,
-        detection: selected.detection
-      };
-    }
-  }
-  let eslintChoices;
-  if (items.includes("eslint")) {
-    const packagesWithEslint = state.packages.filter(
-      (p2) => p2.eslintConfigPath !== null
-    );
-    if (packagesWithEslint.length === 0) {
-      throw new Error(
-        "No packages with eslint.config.{ts,mjs,js,cjs} found. Create an ESLint config first."
-      );
-    }
-    const packagePaths = await prompter.selectEslintPackages(
-      packagesWithEslint
-    );
-    if (packagePaths.length > 0) {
-      let selectedRules = await prompter.selectEslintRules();
-      const severity = await prompter.selectEslintRuleSeverity();
-      if (severity !== "defaults") {
-        selectedRules = selectedRules.map((rule) => ({
-          ...rule,
-          defaultSeverity: severity
-        }));
-      }
-      const hasConfigurableRules = selectedRules.some(
-        (r) => r.optionSchema && r.optionSchema.fields.length > 0
-      );
-      if (hasConfigurableRules) {
-        const customizeOptions = await prompter.confirmCustomizeRuleOptions();
-        if (customizeOptions) {
-          selectedRules = await configureRuleOptions(selectedRules, prompter);
-        }
-      }
-      eslintChoices = { packagePaths, selectedRules };
-    }
-  }
-  return {
-    items,
-    next: nextChoices,
-    vite: viteChoices,
-    eslint: eslintChoices
-  };
-}
-async function configureRuleOptions(rules, prompter) {
-  const configured = [];
-  for (const rule of rules) {
-    if (rule.optionSchema && rule.optionSchema.fields.length > 0) {
-      const options = await prompter.configureRuleOptions(rule);
-      if (options) {
-        const existingOptions = rule.defaultOptions && rule.defaultOptions.length > 0 ? rule.defaultOptions[0] : {};
-        configured.push({
-          ...rule,
-          defaultOptions: [{ ...existingOptions, ...options }]
-        });
-      } else {
-        configured.push(rule);
-      }
-    } else {
-      configured.push(rule);
-    }
-  }
-  return configured;
-}
-
-// src/commands/install.ts
-function displayResults(result) {
-  const { summary } = result;
-  const installedItems = [];
-  if (summary.installedItems.includes("genstyleguide")) {
-    installedItems.push(
-      `${pc.cyan("Command")} \u2192 .cursor/commands/genstyleguide.md`
-    );
-  }
-  if (summary.nextApp) {
-    installedItems.push(
-      `${pc.cyan("Next Routes")} \u2192 ${pc.dim(
-        join16(summary.nextApp.appRoot, "api/.uilint")
-      )}`
-    );
-    installedItems.push(
-      `${pc.cyan("Next Devtools")} \u2192 ${pc.dim("<uilint-devtools /> injected")}`
-    );
-    installedItems.push(
-      `${pc.cyan("JSX Loc Plugin")} \u2192 ${pc.dim(
-        "next.config wrapped with withJsxLoc"
-      )}`
-    );
-  }
-  if (summary.viteApp) {
-    installedItems.push(
-      `${pc.cyan("Vite Devtools")} \u2192 ${pc.dim("<uilint-devtools /> injected")}`
-    );
-    installedItems.push(
-      `${pc.cyan("JSX Loc Plugin")} \u2192 ${pc.dim(
-        "vite.config plugins patched with jsxLoc()"
-      )}`
-    );
-  }
-  if (summary.eslintTargets.length > 0) {
-    installedItems.push(
-      `${pc.cyan("ESLint Plugin")} \u2192 installed in ${summary.eslintTargets.length} package(s)`
-    );
-    for (let i = 0; i < summary.eslintTargets.length; i++) {
-      const isLast = i === summary.eslintTargets.length - 1;
-      const prefix = isLast ? "\u2514" : "\u251C";
-      installedItems.push(
-        `  ${pc.dim(prefix)} ${summary.eslintTargets[i].displayName}`
-      );
-    }
-    installedItems.push(`${pc.cyan("Available Rules")}:`);
-    for (let i = 0; i < ruleRegistry2.length; i++) {
-      const isLast = i === ruleRegistry2.length - 1;
-      const prefix = isLast ? "\u2514" : "\u251C";
-      const rule = ruleRegistry2[i];
-      const suffix = rule.id === "semantic" ? ` ${pc.dim("(LLM-powered)")}` : "";
-      installedItems.push(
-        `  ${pc.dim(prefix)} ${pc.cyan(`uilint/${rule.id}`)}${suffix}`
-      );
-    }
-  }
-  note2(installedItems.join("\n"), "Installed");
-  const steps = [];
-  const hasStyleguide = summary.filesCreated.some(
-    (f) => f.includes("styleguide.md")
-  );
-  if (!hasStyleguide) {
-    steps.push(`Create a styleguide: ${pc.cyan("/genstyleguide")}`);
-  }
-  if (summary.installedItems.includes("genstyleguide")) {
-    steps.push("Restart Cursor to load the new configuration");
-  }
-  if (summary.nextApp) {
-    steps.push(
-      "Run your Next.js dev server - use Alt+Click on any element to inspect"
-    );
-  }
-  if (summary.viteApp) {
-    steps.push(
-      "Run your Vite dev server - use Alt+Click on any element to inspect"
-    );
-  }
-  if (summary.eslintTargets.length > 0) {
-    steps.push(`Run ${pc.cyan("npx eslint src/")} to check for issues`);
-    steps.push(
-      `For real-time overlay integration, run ${pc.cyan(
-        "uilint serve"
-      )} alongside your dev server`
-    );
-  }
-  if (steps.length > 0) {
-    note2(steps.join("\n"), "Next Steps");
-  }
-}
-async function install(options = {}, prompter = cliPrompter, executeOptions = {}) {
-  const projectPath = process.cwd();
-  intro2("Setup Wizard");
-  logInfo("Analyzing project...");
-  const state = await analyze2(projectPath);
-  const choices = await gatherChoices(state, options, prompter);
-  if (choices.items.length === 0) {
-    logWarning("No items selected for installation");
-    outro2("Nothing to install");
-    return {
-      success: true,
-      actionsPerformed: [],
-      dependencyResults: [],
-      summary: {
-        installedItems: [],
-        filesCreated: [],
-        filesModified: [],
-        filesDeleted: [],
-        dependenciesInstalled: [],
-        eslintTargets: []
-      }
-    };
-  }
-  const plan = createPlan(state, choices, { force: options.force });
-  logInfo("Installing...");
-  const result = await withSpinner("Running installation", async () => {
-    return execute(plan, executeOptions);
-  });
-  const failedActions = result.actionsPerformed.filter((r) => !r.success);
-  const failedDeps = result.dependencyResults.filter((r) => !r.success);
-  if (failedActions.length > 0) {
-    for (const failed of failedActions) {
-      logWarning(`Failed: ${failed.action.type} - ${failed.error}`);
-    }
-  }
-  if (failedDeps.length > 0) {
-    for (const failed of failedDeps) {
-      logWarning(
-        `Failed to install dependencies in ${failed.install.packagePath}: ${failed.error}`
-      );
-    }
-  }
-  displayResults(result);
-  if (result.success) {
-    outro2("UILint installed successfully!");
-  } else {
-    outro2("UILint installation completed with some errors");
-  }
-  return result;
-}
-
-// src/commands/serve.ts
-import { existsSync as existsSync18, statSync as statSync4, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
-import { createRequire as createRequire3 } from "module";
-import { dirname as dirname11, resolve as resolve5, relative as relative4, join as join18, parse as parse2 } from "path";
-import { WebSocketServer, WebSocket } from "ws";
-import { watch } from "chokidar";
-import {
-  findWorkspaceRoot as findWorkspaceRoot6,
-  getVisionAnalyzer as getCoreVisionAnalyzer
-} from "uilint-core/node";
-
-// src/utils/vision-run.ts
-import { dirname as dirname10, join as join17, parse } from "path";
-import { existsSync as existsSync17, statSync as statSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync8 } from "fs";
-import {
-  ensureOllamaReady as ensureOllamaReady5,
-  findStyleGuidePath as findStyleGuidePath4,
-  findUILintStyleGuideUpwards as findUILintStyleGuideUpwards3,
-  readStyleGuide as readStyleGuide4,
-  VisionAnalyzer,
-  UILINT_DEFAULT_VISION_MODEL
-} from "uilint-core/node";
-async function resolveVisionStyleGuide(args) {
-  const projectPath = args.projectPath;
-  const startDir = args.startDir ?? projectPath;
-  if (args.styleguide) {
-    const styleguideArg = resolvePathSpecifier(args.styleguide, projectPath);
-    if (existsSync17(styleguideArg)) {
-      const stat = statSync3(styleguideArg);
-      if (stat.isFile()) {
-        return {
-          styleguideLocation: styleguideArg,
-          styleGuide: await readStyleGuide4(styleguideArg)
-        };
-      }
-      if (stat.isDirectory()) {
-        const found = findStyleGuidePath4(styleguideArg);
-        return {
-          styleguideLocation: found,
-          styleGuide: found ? await readStyleGuide4(found) : null
-        };
-      }
-    }
-    return { styleGuide: null, styleguideLocation: null };
-  }
-  const upwards = findUILintStyleGuideUpwards3(startDir);
-  const fallback = upwards ?? findStyleGuidePath4(projectPath);
-  return {
-    styleguideLocation: fallback,
-    styleGuide: fallback ? await readStyleGuide4(fallback) : null
-  };
-}
-var ollamaReadyOnce = /* @__PURE__ */ new Map();
-async function ensureOllamaReadyCached(params) {
-  const key = `${params.baseUrl}::${params.model}`;
-  const existing = ollamaReadyOnce.get(key);
-  if (existing) return existing;
-  const p2 = ensureOllamaReady5({ model: params.model, baseUrl: params.baseUrl }).then(() => void 0).catch((e) => {
-    ollamaReadyOnce.delete(key);
-    throw e;
-  });
-  ollamaReadyOnce.set(key, p2);
-  return p2;
-}
-function writeVisionDebugDump(params) {
-  const resolvedDirOrFile = resolvePathSpecifier(
-    params.dumpPath,
-    process.cwd()
-  );
-  const safeStamp = params.now.toISOString().replace(/[:.]/g, "-");
-  const dumpFile = resolvedDirOrFile.endsWith(".json") || resolvedDirOrFile.endsWith(".jsonl") ? resolvedDirOrFile : `${resolvedDirOrFile}/vision-debug-${safeStamp}.json`;
-  mkdirSync4(dirname10(dumpFile), { recursive: true });
-  writeFileSync8(
-    dumpFile,
-    JSON.stringify(
-      {
-        version: 1,
-        timestamp: params.now.toISOString(),
-        runtime: params.runtime,
-        metadata: params.metadata ?? null,
-        inputs: {
-          imageBase64: params.includeSensitive ? params.inputs.imageBase64 : "(omitted; set debugDumpIncludeSensitive=true)",
-          manifest: params.inputs.manifest,
-          styleguideLocation: params.inputs.styleguideLocation,
-          styleGuide: params.includeSensitive ? params.inputs.styleGuide : "(omitted; set debugDumpIncludeSensitive=true)"
-        }
-      },
-      null,
-      2
-    ),
-    "utf-8"
-  );
-  return dumpFile;
-}
-async function runVisionAnalysis(args) {
-  const visionModel = args.model || UILINT_DEFAULT_VISION_MODEL;
-  const baseUrl = args.baseUrl ?? "http://localhost:11434";
-  let styleGuide = null;
-  let styleguideLocation = null;
-  if (args.styleGuide !== void 0) {
-    styleGuide = args.styleGuide;
-    styleguideLocation = args.styleguideLocation ?? null;
-  } else {
-    args.onPhase?.("Resolving styleguide...");
-    const resolved = await resolveVisionStyleGuide({
-      projectPath: args.projectPath,
-      styleguide: args.styleguide,
-      startDir: args.styleguideStartDir
-    });
-    styleGuide = resolved.styleGuide;
-    styleguideLocation = resolved.styleguideLocation;
-  }
-  if (!args.skipEnsureOllama) {
-    args.onPhase?.("Preparing Ollama...");
-    await ensureOllamaReadyCached({ model: visionModel, baseUrl });
-  }
-  if (args.debugDump) {
-    writeVisionDebugDump({
-      dumpPath: args.debugDump,
-      now: /* @__PURE__ */ new Date(),
-      runtime: { visionModel, baseUrl },
-      inputs: {
-        imageBase64: args.imageBase64,
-        manifest: args.manifest,
-        styleguideLocation,
-        styleGuide
-      },
-      includeSensitive: Boolean(args.debugDumpIncludeSensitive),
-      metadata: args.debugDumpMetadata
-    });
-  }
-  const analyzer = args.analyzer ?? new VisionAnalyzer({
-    baseUrl: args.baseUrl,
-    visionModel
-  });
-  args.onPhase?.(`Analyzing ${args.manifest.length} elements...`);
-  const result = await analyzer.analyzeScreenshot(
-    args.imageBase64,
-    args.manifest,
-    {
-      styleGuide,
-      onProgress: args.onProgress
-    }
-  );
-  args.onPhase?.(
-    `Done (${result.issues.length} issues, ${result.analysisTime}ms)`
-  );
-  return {
-    issues: result.issues,
-    analysisTime: result.analysisTime,
-    // Prompt is available in newer uilint-core versions; keep this resilient across versions.
-    prompt: result.prompt,
-    rawResponse: result.rawResponse,
-    styleguideLocation,
-    visionModel,
-    baseUrl
-  };
-}
-function writeVisionMarkdownReport(args) {
-  const p2 = parse(args.imagePath);
-  const outPath = args.outPath ?? join17(p2.dir, `${p2.name || p2.base}.vision.md`);
-  const lines = [];
-  lines.push(`# UILint Vision Report`);
-  lines.push(``);
-  lines.push(`- Image: \`${p2.base}\``);
-  if (args.route) lines.push(`- Route: \`${args.route}\``);
-  if (typeof args.timestamp === "number") {
-    lines.push(`- Timestamp: \`${new Date(args.timestamp).toISOString()}\``);
-  }
-  if (args.visionModel) lines.push(`- Model: \`${args.visionModel}\``);
-  if (args.baseUrl) lines.push(`- Ollama baseUrl: \`${args.baseUrl}\``);
-  if (typeof args.analysisTimeMs === "number")
-    lines.push(`- Analysis time: \`${args.analysisTimeMs}ms\``);
-  lines.push(`- Generated: \`${(/* @__PURE__ */ new Date()).toISOString()}\``);
-  lines.push(``);
-  if (args.metadata && Object.keys(args.metadata).length > 0) {
-    lines.push(`## Metadata`);
-    lines.push(``);
-    lines.push("```json");
-    lines.push(JSON.stringify(args.metadata, null, 2));
-    lines.push("```");
-    lines.push(``);
-  }
-  lines.push(`## Prompt`);
-  lines.push(``);
-  lines.push("```text");
-  lines.push((args.prompt ?? "").trim());
-  lines.push("```");
-  lines.push(``);
-  lines.push(`## Raw Response`);
-  lines.push(``);
-  lines.push("```text");
-  lines.push((args.rawResponse ?? "").trim());
-  lines.push("```");
-  lines.push(``);
-  const content = lines.join("\n");
-  mkdirSync4(dirname10(outPath), { recursive: true });
-  writeFileSync8(outPath, content, "utf-8");
-  return { outPath, content };
-}
-
-// src/commands/serve.ts
-function pickAppRoot(params) {
-  const { cwd, workspaceRoot } = params;
-  if (detectNextAppRouter(cwd)) return cwd;
-  const matches = findNextAppRouterProjects(workspaceRoot, { maxDepth: 5 });
-  if (matches.length === 0) return cwd;
-  if (matches.length === 1) return matches[0].projectPath;
-  const containing = matches.find(
-    (m) => cwd === m.projectPath || cwd.startsWith(m.projectPath + "/")
-  );
-  if (containing) return containing.projectPath;
-  return matches[0].projectPath;
-}
-var cache = /* @__PURE__ */ new Map();
-var eslintInstances = /* @__PURE__ */ new Map();
-var visionAnalyzer = null;
-function getVisionAnalyzerInstance() {
-  if (!visionAnalyzer) {
-    visionAnalyzer = getCoreVisionAnalyzer();
-  }
-  return visionAnalyzer;
-}
-var serverAppRootForVision = process.cwd();
-function isValidScreenshotFilename(filename) {
-  const validPattern = /^[a-zA-Z0-9_-]+\.(png|jpeg|jpg)$/;
-  return validPattern.test(filename) && !filename.includes("..");
+var serverAppRootForVision = process.cwd();
+function isValidScreenshotFilename(filename) {
+  const validPattern = /^[a-zA-Z0-9_-]+\.(png|jpeg|jpg)$/;
+  return validPattern.test(filename) && !filename.includes("..");
 }
 var resolvedPathCache = /* @__PURE__ */ new Map();
 var subscriptions = /* @__PURE__ */ new Map();
 var fileWatcher = null;
 var connectedClients = 0;
-var localRequire = createRequire3(import.meta.url);
+var localRequire = createRequire(import.meta.url);
 function buildLineStarts(code) {
   const starts = [0];
   for (let i = 0; i < code.length; i++) {
@@ -5171,7 +1731,7 @@ function mapMessageToDataLoc(params) {
   }
   return void 0;
 }
-var ESLINT_CONFIG_FILES2 = [
+var ESLINT_CONFIG_FILES = [
   // Flat config (ESLint v9+)
   "eslint.config.js",
   "eslint.config.mjs",
@@ -5188,11 +1748,11 @@ var ESLINT_CONFIG_FILES2 = [
 function findESLintCwd(startDir) {
   let dir = startDir;
   for (let i = 0; i < 30; i++) {
-    for (const cfg of ESLINT_CONFIG_FILES2) {
-      if (existsSync18(join18(dir, cfg))) return dir;
+    for (const cfg of ESLINT_CONFIG_FILES) {
+      if (existsSync5(join4(dir, cfg))) return dir;
     }
-    if (existsSync18(join18(dir, "package.json"))) return dir;
-    const parent = dirname11(dir);
+    if (existsSync5(join4(dir, "package.json"))) return dir;
+    const parent = dirname6(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -5205,7 +1765,7 @@ function normalizeDataLocFilePath(absoluteFilePath, projectCwd) {
   const abs = normalizePathSlashes(resolve5(absoluteFilePath));
   const cwd = normalizePathSlashes(resolve5(projectCwd));
   if (abs === cwd || abs.startsWith(cwd + "/")) {
-    return normalizePathSlashes(relative4(cwd, abs));
+    return normalizePathSlashes(relative(cwd, abs));
   }
   return abs;
 }
@@ -5217,25 +1777,25 @@ function resolveRequestedFilePath(filePath) {
   if (cached) return cached;
   const cwd = process.cwd();
   const fromCwd = resolve5(cwd, filePath);
-  if (existsSync18(fromCwd)) {
+  if (existsSync5(fromCwd)) {
     resolvedPathCache.set(filePath, fromCwd);
     return fromCwd;
   }
-  const wsRoot = findWorkspaceRoot6(cwd);
+  const wsRoot = findWorkspaceRoot4(cwd);
   const fromWs = resolve5(wsRoot, filePath);
-  if (existsSync18(fromWs)) {
+  if (existsSync5(fromWs)) {
     resolvedPathCache.set(filePath, fromWs);
     return fromWs;
   }
   for (const top of ["apps", "packages"]) {
-    const base = join18(wsRoot, top);
-    if (!existsSync18(base)) continue;
+    const base = join4(wsRoot, top);
+    if (!existsSync5(base)) continue;
     try {
-      const entries = readdirSync5(base, { withFileTypes: true });
+      const entries = readdirSync(base, { withFileTypes: true });
       for (const ent of entries) {
         if (!ent.isDirectory()) continue;
         const p2 = resolve5(base, ent.name, filePath);
-        if (existsSync18(p2)) {
+        if (existsSync5(p2)) {
           resolvedPathCache.set(filePath, p2);
           return p2;
         }
@@ -5250,7 +1810,7 @@ async function getESLintForProject(projectCwd) {
   const cached = eslintInstances.get(projectCwd);
   if (cached) return cached;
   try {
-    const req = createRequire3(join18(projectCwd, "package.json"));
+    const req = createRequire(join4(projectCwd, "package.json"));
     const mod = req("eslint");
     const ESLintCtor = mod?.ESLint ?? mod?.default?.ESLint ?? mod?.default ?? mod;
     if (!ESLintCtor) return null;
@@ -5263,13 +1823,13 @@ async function getESLintForProject(projectCwd) {
 }
 async function lintFile(filePath, onProgress) {
   const absolutePath = resolveRequestedFilePath(filePath);
-  if (!existsSync18(absolutePath)) {
+  if (!existsSync5(absolutePath)) {
     onProgress(`File not found: ${pc.dim(absolutePath)}`);
     return [];
   }
   const mtimeMs = (() => {
     try {
-      return statSync4(absolutePath).mtimeMs;
+      return statSync3(absolutePath).mtimeMs;
     } catch {
       return 0;
     }
@@ -5279,7 +1839,7 @@ async function lintFile(filePath, onProgress) {
     onProgress("Cache hit (unchanged)");
     return cached.issues;
   }
-  const fileDir = dirname11(absolutePath);
+  const fileDir = dirname6(absolutePath);
   const projectCwd = findESLintCwd(fileDir);
   onProgress(`Resolving ESLint project... ${pc.dim(projectCwd)}`);
   const eslint = await getESLintForProject(projectCwd);
@@ -5302,7 +1862,7 @@ async function lintFile(filePath, onProgress) {
     let codeLength = 0;
     try {
       onProgress("Building JSX map...");
-      const code = readFileSync12(absolutePath, "utf-8");
+      const code = readFileSync2(absolutePath, "utf-8");
       codeLength = code.length;
       lineStarts = buildLineStarts(code);
       spans = buildJsxElementSpans(code, dataLocFile);
@@ -5384,9 +1944,9 @@ async function handleMessage(ws, data) {
       });
       const startedAt = Date.now();
       const resolved = resolveRequestedFilePath(filePath);
-      if (!existsSync18(resolved)) {
+      if (!existsSync5(resolved)) {
         const cwd = process.cwd();
-        const wsRoot = findWorkspaceRoot6(cwd);
+        const wsRoot = findWorkspaceRoot4(cwd);
         logWarning(
           [
             `${pc.dim("[ws]")} File not found for request`,
@@ -5546,14 +2106,14 @@ async function handleMessage(ws, data) {
               )}`
             );
           } else {
-            const screenshotsDir = join18(
+            const screenshotsDir = join4(
               serverAppRootForVision,
               ".uilint",
               "screenshots"
             );
-            const imagePath = join18(screenshotsDir, screenshotFile);
+            const imagePath = join4(screenshotsDir, screenshotFile);
             try {
-              if (!existsSync18(imagePath)) {
+              if (!existsSync5(imagePath)) {
                 logWarning(
                   `Skipping vision report write: screenshot file not found ${pc.dim(
                     imagePath
@@ -5661,7 +2221,7 @@ function handleFileChange(filePath) {
 async function serve(options) {
   const port = options.port || 9234;
   const cwd = process.cwd();
-  const wsRoot = findWorkspaceRoot6(cwd);
+  const wsRoot = findWorkspaceRoot4(cwd);
   const appRoot = pickAppRoot({ cwd, workspaceRoot: wsRoot });
   serverAppRootForVision = appRoot;
   logInfo(`Workspace root: ${pc.dim(wsRoot)}`);
@@ -5714,11 +2274,11 @@ async function serve(options) {
 }
 
 // src/commands/vision.ts
-import { dirname as dirname12, resolve as resolve6, join as join19 } from "path";
+import { dirname as dirname7, resolve as resolve6, join as join5 } from "path";
 import {
-  existsSync as existsSync19,
-  readFileSync as readFileSync13,
-  readdirSync as readdirSync6
+  existsSync as existsSync6,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2
 } from "fs";
 import {
   ensureOllamaReady as ensureOllamaReady6,
@@ -5730,9 +2290,9 @@ function envTruthy3(name) {
   if (!v) return false;
   return v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes";
 }
-function preview3(text3, maxLen) {
-  if (text3.length <= maxLen) return text3;
-  return text3.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text3.slice(-maxLen);
+function preview3(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text2.slice(-maxLen);
 }
 function debugEnabled3(options) {
   return Boolean(options.debug) || envTruthy3("UILINT_DEBUG");
@@ -5763,17 +2323,17 @@ function debugLog3(enabled, message, obj) {
 function findScreenshotsDirUpwards(startDir) {
   let dir = startDir;
   for (let i = 0; i < 20; i++) {
-    const candidate = join19(dir, ".uilint", "screenshots");
-    if (existsSync19(candidate)) return candidate;
-    const parent = dirname12(dir);
+    const candidate = join5(dir, ".uilint", "screenshots");
+    if (existsSync6(candidate)) return candidate;
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function listScreenshotSidecars(dirPath) {
-  if (!existsSync19(dirPath)) return [];
-  const entries = readdirSync6(dirPath).filter((f) => f.endsWith(".json")).map((f) => join19(dirPath, f));
+  if (!existsSync6(dirPath)) return [];
+  const entries = readdirSync2(dirPath).filter((f) => f.endsWith(".json")).map((f) => join5(dirPath, f));
   const out = [];
   for (const p2 of entries) {
     try {
@@ -5802,11 +2362,11 @@ function listScreenshotSidecars(dirPath) {
   return out;
 }
 function readImageAsBase64(imagePath) {
-  const bytes = readFileSync13(imagePath);
+  const bytes = readFileSync3(imagePath);
   return { base64: bytes.toString("base64"), sizeBytes: bytes.byteLength };
 }
 function loadJsonFile(filePath) {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync3(filePath, "utf-8");
   return JSON.parse(raw);
 }
 function formatIssuesText(issues) {
@@ -5880,13 +2440,13 @@ async function vision(options) {
       await flushLangfuse();
       process.exit(1);
     }
-    if (imagePath && !existsSync19(imagePath)) {
+    if (imagePath && !existsSync6(imagePath)) {
       throw new Error(`Image not found: ${imagePath}`);
     }
-    if (sidecarPath && !existsSync19(sidecarPath)) {
+    if (sidecarPath && !existsSync6(sidecarPath)) {
       throw new Error(`Sidecar not found: ${sidecarPath}`);
     }
-    if (manifestFilePath && !existsSync19(manifestFilePath)) {
+    if (manifestFilePath && !existsSync6(manifestFilePath)) {
       throw new Error(`Manifest file not found: ${manifestFilePath}`);
     }
     const sidecar = sidecarPath ? loadJsonFile(sidecarPath) : null;
@@ -5911,7 +2471,7 @@ async function vision(options) {
       const resolved = await resolveVisionStyleGuide({
         projectPath,
         styleguide: options.styleguide,
-        startDir: startPath ? dirname12(startPath) : projectPath
+        startDir: startPath ? dirname7(startPath) : projectPath
       });
       styleGuide = resolved.styleGuide;
       styleguideLocation = resolved.styleguideLocation;
@@ -5960,7 +2520,7 @@ async function vision(options) {
     const resolvedImagePath = imagePath || (() => {
       const screenshotFile = typeof sidecar?.screenshotFile === "string" ? sidecar.screenshotFile : typeof sidecar?.filename === "string" ? sidecar.filename : void 0;
       if (!screenshotFile) return null;
-      const baseDir = sidecarPath ? dirname12(sidecarPath) : projectPath;
+      const baseDir = sidecarPath ? dirname7(sidecarPath) : projectPath;
       const abs = resolve6(baseDir, screenshotFile);
       return abs;
     })();
@@ -5969,7 +2529,7 @@ async function vision(options) {
         "No image path could be resolved. Provide --image or a sidecar with `screenshotFile`/`filename`."
       );
     }
-    if (!existsSync19(resolvedImagePath)) {
+    if (!existsSync6(resolvedImagePath)) {
       throw new Error(`Image not found: ${resolvedImagePath}`);
     }
     const { base64, sizeBytes } = readImageAsBase64(resolvedImagePath);
@@ -6197,9 +2757,9 @@ async function vision(options) {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname13, join as join20 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname8, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function assertNodeVersion(minMajor) {
   const ver = process.versions.node || "";
   const majorStr = ver.split(".")[0] || "";
@@ -6215,9 +2775,9 @@ assertNodeVersion(20);
 var program = new Command();
 function getCLIVersion2() {
   try {
-    const __dirname3 = dirname13(fileURLToPath4(import.meta.url));
-    const pkgPath = join20(__dirname3, "..", "package.json");
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const __dirname = dirname8(fileURLToPath2(import.meta.url));
+    const pkgPath = join6(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -6290,20 +2850,9 @@ program.command("update").description("Update existing style guide with new styl
     llm: options.llm
   });
 });
-program.command("install").description("Install UILint integration").option("--force", "Overwrite existing configuration files").option("--genstyleguide", "Install /genstyleguide Cursor command").option("--eslint", "Install uilint-eslint plugin and configure ESLint").option(
-  "--routes",
-  "Back-compat: install Next.js overlay (routes + deps + inject)"
-).option(
-  "--react",
-  "Back-compat: install Next.js overlay (routes + deps + inject)"
-).action(async (options) => {
-  await install({
-    force: options.force,
-    genstyleguide: options.genstyleguide,
-    eslint: options.eslint,
-    routes: options.routes,
-    react: options.react
-  });
+program.command("install").description("Install UILint integration").option("--force", "Overwrite existing configuration files").action(async (options) => {
+  const { installUI } = await import("./install-ui-OEFHX4FG.js");
+  await installUI({ force: options.force });
 });
 program.command("serve").description("Start WebSocket server for real-time UI linting").option("-p, --port <number>", "Port to listen on", "9234").action(async (options) => {
   await serve({