uilint 0.2.3 → 0.2.5

package/dist/index.js

@@ -357,8 +357,8 @@ import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 function getCLIVersion() {
   try {
-    const __dirname2 = dirname(fileURLToPath(import.meta.url));
-    const pkgPath = join2(__dirname2, "..", "..", "package.json");
+    const __dirname3 = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join2(__dirname3, "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
@@ -1475,13 +1475,13 @@ async function update(options) {
 }
 
 // src/commands/install.ts
-import { join as join15 } from "path";
+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 findWorkspaceRoot4 } from "uilint-core/node";
+import { findWorkspaceRoot as findWorkspaceRoot5 } from "uilint-core/node";
 
 // src/utils/next-detect.ts
 import { existsSync as existsSync4, readdirSync } from "fs";
@@ -1714,6 +1714,24 @@ function isFrontendPackage(pkgJson) {
   };
   return FRONTEND_INDICATORS.some((pkg) => pkg in deps);
 }
+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;
+    }
+  }
+  return false;
+}
 function hasEslintConfig(dir) {
   for (const file of ESLINT_CONFIG_FILES) {
     if (existsSync6(join5(dir, file))) {
@@ -1747,7 +1765,8 @@ function findPackages(rootDir, options) {
         name,
         hasEslintConfig: hasEslintConfig(dir),
         isFrontend: isFrontendPackage(pkg),
-        isRoot
+        isRoot,
+        isTypeScript: isTypeScriptPackage(dir, pkg)
       };
     } catch {
       return null;
@@ -1853,8 +1872,9 @@ async function installDependencies(pm, projectPath, packages) {
 
 // src/utils/eslint-config-inject.ts
 import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+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) {
@@ -1869,25 +1889,6 @@ function getEslintConfigFilename(configPath) {
   const parts = configPath.split("/");
   return parts[parts.length - 1] || "eslint.config.mjs";
 }
-function hasUilintImport(source) {
-  return source.includes('from "uilint-eslint"') || source.includes("from 'uilint-eslint'") || source.includes('require("uilint-eslint")') || source.includes("require('uilint-eslint')");
-}
-function hasUilintConfigsUsage(source) {
-  return /\builint\s*\.\s*configs\s*\./.test(source);
-}
-function walkAst(node, visit) {
-  if (!node || typeof node !== "object") return;
-  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 isIdentifier(node, name) {
   return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
 }
@@ -1912,35 +1913,6 @@ function hasSpreadProperties(obj) {
     (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;
@@ -1951,8 +1923,9 @@ function collectUilintRuleIdsFromRulesObject(rulesObj) {
     if (!isStringLiteral(key)) continue;
     const val = key.value;
     if (typeof val !== "string") continue;
-    if (!val.startsWith("uilint/")) continue;
-    ids.add(val.slice("uilint/".length));
+    if (val.startsWith("uilint/")) {
+      ids.add(val.slice("uilint/".length));
+    }
   }
   return ids;
 }
@@ -2045,24 +2018,6 @@ function findExportedConfigArrayExpression(mod) {
   }
   return null;
 }
-function findUsesUilintConfigs(program2) {
-  let found = false;
-  walkAst(program2, (n) => {
-    if (found) return;
-    if (n?.type === "MemberExpression") {
-      const obj = n.object;
-      const prop = n.property;
-      if (isIdentifier(prop, "configs") && isIdentifier(obj, "uilint")) {
-        found = true;
-        return;
-      }
-      if (obj?.type === "MemberExpression" && isIdentifier(obj.object, "uilint") && isIdentifier(obj.property, "configs")) {
-        found = true;
-      }
-    }
-  });
-  return found;
-}
 function collectConfiguredUilintRuleIdsFromConfigArray(arrayExpr) {
   const ids = /* @__PURE__ */ new Set();
   if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return ids;
@@ -2115,69 +2070,68 @@ function chooseUniqueIdentifier(base, used) {
   while (used.has(`${base}${i}`)) i++;
   return `${base}${i}`;
 }
-function getEsmUilintDefaultImportLocal(mod) {
-  const items = mod?.imports?.$items ?? [];
-  const found = items.find(
-    (it) => it?.from === "uilint-eslint" && it?.imported === "default"
-  );
-  return found?.local ?? null;
-}
-function ensureUilintImportAst(mod) {
-  const existing = getEsmUilintDefaultImportLocal(mod);
-  if (existing) return { local: existing, changed: false };
-  mod.imports.$prepend({
-    imported: "default",
-    local: "uilint",
-    from: "uilint-eslint"
-  });
-  return { local: "uilint", changed: true };
-}
-function findCjsUilintRequireBinding(program2) {
-  if (!program2 || program2.type !== "Program") return null;
-  for (const stmt of program2.body ?? []) {
-    if (stmt?.type !== "VariableDeclaration") continue;
-    for (const decl of stmt.declarations ?? []) {
-      const id = decl?.id;
-      const init = decl?.init;
-      if (!isIdentifier(id)) continue;
-      if (init?.type === "CallExpression" && isIdentifier(init.callee, "require") && isStringLiteral(init.arguments?.[0]) && init.arguments[0].value === "uilint-eslint") {
-        return id.name;
-      }
-    }
+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 null;
+  return { importNames, changed };
 }
-function ensureUilintRequireAst(program2) {
+function addLocalRuleRequiresAst(program2, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
+  const importNames = /* @__PURE__ */ new Map();
+  let changed = false;
   if (!program2 || program2.type !== "Program") {
-    return { local: "uilint", changed: false };
+    return { importNames, changed };
   }
-  const existing = findCjsUilintRequireBinding(program2);
-  if (existing) return { local: existing, 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(program2);
-  const local = chooseUniqueIdentifier("uilint", used);
-  const stmtMod = parseModule(`const ${local} = require("uilint-eslint");`);
-  const stmt = stmtMod.$ast.body?.[0];
-  if (!stmt) return { local, changed: false };
-  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);
-  return { local, changed: true };
-}
-function buildUilintRuleProperty(rule) {
-  const ruleKey = `uilint/${rule.id}`;
-  const valueCode = rule.defaultOptions && rule.defaultOptions.length > 0 ? `["${rule.defaultSeverity}", ...${JSON.stringify(
-    rule.defaultOptions,
-    null,
-    2
-  )}]` : `"${rule.defaultSeverity}"`;
-  const expr = parseExpression(`({ "${ruleKey}": ${valueCode} })`);
-  const obj = expr.$ast;
-  return obj.properties?.[0];
-}
-function appendUilintConfigBlockToArray(arrayExpr, selectedRules, uilintRef) {
+  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(
@@ -2193,7 +2147,13 @@ function appendUilintConfigBlockToArray(arrayExpr, selectedRules, uilintRef) {
       "app/**/*.{js,jsx,ts,tsx}",
       "pages/**/*.{js,jsx,ts,tsx}",
     ],
-    plugins: { uilint: ${uilintRef} },
+    plugins: {
+      uilint: {
+        rules: {
+${pluginRulesCode}
+        },
+      },
+    },
     rules: {
 ${rulesPropsCode}
     },
@@ -2210,14 +2170,13 @@ function getUilintEslintConfigInfoFromSourceAst(source) {
         error: "Could not locate an exported ESLint flat config array (expected `export default [...]`, `export default defineConfig([...])`, `module.exports = [...]`, or `module.exports = defineConfig([...])`)."
       };
     }
-    const usesUilintConfigs = findUsesUilintConfigs(found.program);
     const configuredRuleIds = collectConfiguredUilintRuleIdsFromConfigArray(
       found.arrayExpr
     );
     const existingUilint = findExistingUilintRulesObject(found.arrayExpr);
-    const configured = usesUilintConfigs || configuredRuleIds.size > 0 || existingUilint.configObj !== null || hasUilintImport(source);
+    const configured = configuredRuleIds.size > 0 || existingUilint.configObj !== null;
     return {
-      info: { usesUilintConfigs, configuredRuleIds, configured },
+      info: { configuredRuleIds, configured },
       mod,
       arrayExpr: found.arrayExpr,
       kind: found.kind
@@ -2232,11 +2191,9 @@ function getUilintEslintConfigInfoFromSource(source) {
   const ast = getUilintEslintConfigInfoFromSourceAst(source);
   if ("error" in ast) {
     const configuredRuleIds = extractConfiguredUilintRuleIds(source);
-    const usesUilintConfigs = hasUilintConfigsUsage(source);
     return {
-      usesUilintConfigs,
       configuredRuleIds,
-      configured: usesUilintConfigs || configuredRuleIds.size > 0 || hasUilintImport(source)
+      configured: configuredRuleIds.size > 0
     };
   }
   return ast.info;
@@ -2279,10 +2236,15 @@ async function installEslintPlugin(opts) {
     };
   }
   const { info, mod, arrayExpr, kind } = ast;
-  const usesUilintConfigs = info.usesUilintConfigs;
   const configuredIds = info.configuredRuleIds;
-  const missingRules = usesUilintConfigs ? [] : getMissingSelectedRules(opts.selectedRules, configuredIds);
-  const rulesToUpdate = usesUilintConfigs ? [] : getRulesNeedingUpdate(opts.selectedRules, configuredIds);
+  const missingRules = getMissingSelectedRules(
+    opts.selectedRules,
+    configuredIds
+  );
+  const rulesToUpdate = getRulesNeedingUpdate(
+    opts.selectedRules,
+    configuredIds
+  );
   let rulesToApply = [];
   if (!info.configured) {
     rulesToApply = opts.selectedRules;
@@ -2303,47 +2265,79 @@ async function installEslintPlugin(opts) {
       }
     }
   }
+  if (rulesToApply.length === 0) {
+    return {
+      configFile: configFilename,
+      modified: false,
+      missingRuleIds: missingRules.map((r) => r.id),
+      configured: info.configured
+    };
+  }
   let modifiedAst = false;
-  if (!usesUilintConfigs && rulesToApply.length > 0) {
-    const existing = findExistingUilintRulesObject(arrayExpr);
-    if (existing.safeToMutate && existing.rulesObj) {
-      let changedRules = false;
-      for (const rule of rulesToApply) {
-        const fullKey = `uilint/${rule.id}`;
-        const props = existing.rulesObj.properties ?? [];
-        const existingProp = props.find((p2) => {
-          if (!p2) return false;
-          if (p2.type !== "ObjectProperty" && p2.type !== "Property")
-            return false;
-          return isStringLiteral(p2.key) && p2.key.value === fullKey;
-        });
-        const newProp = buildUilintRuleProperty(rule);
-        if (!newProp) continue;
-        if (existingProp) {
-          if (!astEquivalent(existingProp.value, newProp.value)) {
-            existingProp.value = newProp.value;
-            changedRules = true;
-          }
-        } else {
-          props.push(newProp);
-          changedRules = true;
-        }
-      }
-      if (changedRules) modifiedAst = true;
-    } else {
-      const uilintRef = kind === "esm" ? ensureUilintImportAst(mod).local : ensureUilintRequireAst(mod.$ast).local;
-      appendUilintConfigBlockToArray(arrayExpr, rulesToApply, uilintRef);
-      modifiedAst = true;
+  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";
     }
-  } else if (!info.configured && !usesUilintConfigs) {
   }
-  if (modifiedAst || info.configured) {
+  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") {
-      const { changed } = ensureUilintImportAst(mod);
-      if (changed) modifiedAst = true;
-    } else if (kind === "cjs") {
-      const { changed } = ensureUilintRequireAst(mod.$ast);
-      if (changed) modifiedAst = true;
+      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;
@@ -2375,7 +2369,7 @@ function safeParseJson(filePath) {
   }
 }
 async function analyze2(projectPath = process.cwd()) {
-  const workspaceRoot = findWorkspaceRoot4(projectPath);
+  const workspaceRoot = findWorkspaceRoot5(projectPath);
   const packageManager = detectPackageManager(projectPath);
   const cursorDir = join8(projectPath, ".cursor");
   const cursorDirExists = existsSync9(cursorDir);
@@ -2435,7 +2429,7 @@ async function analyze2(projectPath = process.cwd()) {
       try {
         const source = readFileSync5(eslintConfigPath, "utf-8");
         const info = getUilintEslintConfigInfoFromSource(source);
-        hasRules = info.configuredRuleIds.size > 0 || info.usesUilintConfigs;
+        hasRules = info.configuredRuleIds.size > 0;
         configuredRuleIds = Array.from(info.configuredRuleIds);
       } catch {
       }
@@ -2483,8 +2477,8 @@ async function analyze2(projectPath = process.cwd()) {
 }
 
 // src/commands/install/plan.ts
-import { join as join10 } from "path";
-import { createRequire } from "module";
+import { join as join11 } from "path";
+import { createRequire as createRequire2 } from "module";
 
 // src/commands/install/constants.ts
 var HOOKS_CONFIG = {
@@ -2874,10 +2868,10 @@ Generate in \`.uilint/rules/\`:
 
 // 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 dirname6, relative as relative2 } from "path";
+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 = dirname6(__filename);
+var __dirname = dirname7(__filename);
 function getSkillsDir() {
   const devPath = join9(__dirname, "..", "..", "skills");
   const prodPath = join9(__dirname, "..", "skills");
@@ -2900,7 +2894,7 @@ function collectFiles(dir, baseDir) {
     if (stat.isDirectory()) {
       files.push(...collectFiles(fullPath, baseDir));
     } else if (stat.isFile()) {
-      const relativePath = relative2(baseDir, fullPath);
+      const relativePath = relative3(baseDir, fullPath);
       const content = readFileSync6(fullPath, "utf-8");
       files.push({ relativePath, content });
     }
@@ -2921,11 +2915,154 @@ function loadSkill(name) {
   return { name, files };
 }
 
-// src/commands/install/plan.ts
+// 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 = require2("uilint/package.json");
+    const pkgJson = require3("uilint/package.json");
     const deps = pkgJson?.dependencies;
     const optDeps = pkgJson?.optionalDependencies;
     const peerDeps = pkgJson?.peerDependencies;
@@ -3000,7 +3137,7 @@ function createPlan(state, choices, options = {}) {
     }
   }
   if (items.includes("hooks")) {
-    const hooksDir = join10(state.cursorDir.path, "hooks");
+    const hooksDir = join11(state.cursorDir.path, "hooks");
     actions.push({
       type: "create_directory",
       path: hooksDir
@@ -3026,63 +3163,66 @@ function createPlan(state, choices, options = {}) {
     });
     actions.push({
       type: "create_file",
-      path: join10(hooksDir, "uilint-session-start.sh"),
+      path: join11(hooksDir, "uilint-session-start.sh"),
       content: SESSION_START_SCRIPT,
       permissions: 493
     });
     actions.push({
       type: "create_file",
-      path: join10(hooksDir, "uilint-track.sh"),
+      path: join11(hooksDir, "uilint-track.sh"),
       content: TRACK_SCRIPT,
       permissions: 493
     });
     actions.push({
       type: "create_file",
-      path: join10(hooksDir, "uilint-session-end.sh"),
+      path: join11(hooksDir, "uilint-session-end.sh"),
       content: SESSION_END_SCRIPT,
       permissions: 493
     });
   }
   if (items.includes("genstyleguide")) {
-    const commandsDir = join10(state.cursorDir.path, "commands");
+    const commandsDir = join11(state.cursorDir.path, "commands");
     actions.push({
       type: "create_directory",
       path: commandsDir
     });
     actions.push({
       type: "create_file",
-      path: join10(commandsDir, "genstyleguide.md"),
+      path: join11(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
   }
   if (items.includes("genrules")) {
-    const commandsDir = join10(state.cursorDir.path, "commands");
+    const commandsDir = join11(state.cursorDir.path, "commands");
     actions.push({
       type: "create_directory",
       path: commandsDir
     });
     actions.push({
       type: "create_file",
-      path: join10(commandsDir, "genrules.md"),
+      path: join11(commandsDir, "genrules.md"),
       content: GENRULES_COMMAND_MD
     });
   }
   if (items.includes("skill")) {
-    const skillsDir = join10(state.cursorDir.path, "skills");
+    const skillsDir = join11(state.cursorDir.path, "skills");
     actions.push({
       type: "create_directory",
       path: skillsDir
     });
     try {
       const skill = loadSkill("ui-consistency-enforcer");
-      const skillDir = join10(skillsDir, skill.name);
+      const skillDir = join11(skillsDir, skill.name);
       actions.push({
         type: "create_directory",
         path: skillDir
       });
       for (const file of skill.files) {
-        const filePath = join10(skillDir, file.relativePath);
-        const fileDir = join10(skillDir, file.relativePath.split("/").slice(0, -1).join("/"));
+        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",
@@ -3142,6 +3282,32 @@ function createPlan(state, choices, options = {}) {
     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,
@@ -3157,7 +3323,7 @@ function createPlan(state, choices, options = {}) {
         });
       }
     }
-    const gitignorePath = join10(state.workspaceRoot, ".gitignore");
+    const gitignorePath = join11(state.workspaceRoot, ".gitignore");
     actions.push({
       type: "append_to_file",
       path: gitignorePath,
@@ -3170,49 +3336,49 @@ function createPlan(state, choices, options = {}) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync3,
   writeFileSync as writeFileSync7,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   unlinkSync,
   chmodSync
 } from "fs";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/utils/react-inject.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
+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 = [
-    join11(appRoot, "main.tsx"),
-    join11(appRoot, "main.jsx"),
-    join11(appRoot, "main.ts"),
-    join11(appRoot, "main.js")
+    join12(appRoot, "main.tsx"),
+    join12(appRoot, "main.jsx"),
+    join12(appRoot, "main.ts"),
+    join12(appRoot, "main.js")
   ];
   const existingViteMain = viteMainCandidates.filter(
-    (rel) => existsSync11(join11(projectPath, rel))
+    (rel) => existsSync12(join12(projectPath, rel))
   );
   if (existingViteMain.length > 0) return existingViteMain;
-  const viteAppCandidates = [join11(appRoot, "App.tsx"), join11(appRoot, "App.jsx")];
+  const viteAppCandidates = [join12(appRoot, "App.tsx"), join12(appRoot, "App.jsx")];
   const existingViteApp = viteAppCandidates.filter(
-    (rel) => existsSync11(join11(projectPath, rel))
+    (rel) => existsSync12(join12(projectPath, rel))
   );
   if (existingViteApp.length > 0) return existingViteApp;
   const layoutCandidates = [
-    join11(appRoot, "layout.tsx"),
-    join11(appRoot, "layout.jsx"),
-    join11(appRoot, "layout.ts"),
-    join11(appRoot, "layout.js")
+    join12(appRoot, "layout.tsx"),
+    join12(appRoot, "layout.jsx"),
+    join12(appRoot, "layout.ts"),
+    join12(appRoot, "layout.js")
   ];
   const existingLayouts = layoutCandidates.filter(
-    (rel) => existsSync11(join11(projectPath, rel))
+    (rel) => existsSync12(join12(projectPath, rel))
   );
   if (existingLayouts.length > 0) {
     return existingLayouts;
   }
-  const pageCandidates = [join11(appRoot, "page.tsx"), join11(appRoot, "page.jsx")];
-  return pageCandidates.filter((rel) => existsSync11(join11(projectPath, rel)));
+  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";
@@ -3225,16 +3391,16 @@ function findImportDeclaration(program2, from) {
   }
   return null;
 }
-function walkAst2(node, visit) {
+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) walkAst2(item, visit);
+      for (const item of v) walkAst(item, visit);
     } else if (typeof v === "object" && v.type) {
-      walkAst2(v, visit);
+      walkAst(v, visit);
     }
   }
 }
@@ -3266,7 +3432,7 @@ function ensureNamedImport(program2, from, name) {
 }
 function hasUILintProviderJsx(program2) {
   let found = false;
-  walkAst2(program2, (node) => {
+  walkAst(program2, (node) => {
     if (found) return;
     if (node.type !== "JSXElement") return;
     const name = node.openingElement?.name;
@@ -3286,7 +3452,7 @@ function wrapFirstChildrenExpressionWithProvider(program2) {
   if (!providerJsx || providerJsx.type !== "JSXElement")
     return { changed: false };
   let replaced = false;
-  walkAst2(program2, (node) => {
+  walkAst(program2, (node) => {
     if (replaced) return;
     if (node.type === "JSXExpressionContainer" && node.expression?.type === "Identifier" && node.expression.name === "children") {
       Object.keys(node).forEach((k) => delete node[k]);
@@ -3310,7 +3476,7 @@ function wrapFirstRenderCallArgumentWithProvider(program2) {
     return { changed: false };
   providerJsx.children = providerJsx.children ?? [];
   let wrapped = false;
-  walkAst2(program2, (node) => {
+  walkAst(program2, (node) => {
     if (wrapped) return;
     if (node.type !== "CallExpression") return;
     const callee = node.callee;
@@ -3345,8 +3511,8 @@ async function installReactUILintOverlay(opts) {
   } else {
     chosen = candidates[0];
   }
-  const absTarget = join11(opts.projectPath, chosen);
-  const original = readFileSync7(absTarget, "utf-8");
+  const absTarget = join12(opts.projectPath, chosen);
+  const original = readFileSync8(absTarget, "utf-8");
   let mod;
   try {
     mod = parseModule2(original);
@@ -3380,14 +3546,14 @@ async function installReactUILintOverlay(opts) {
 }
 
 // src/utils/next-config-inject.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12 } from "path";
+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 = join12(projectPath, `next.config${ext}`);
-    if (existsSync12(configPath)) {
+    const configPath = join13(projectPath, `next.config${ext}`);
+    if (existsSync13(configPath)) {
       return configPath;
     }
   }
@@ -3500,7 +3666,7 @@ async function installJsxLocPlugin(opts) {
     return { configFile: null, modified: false };
   }
   const configFilename = getNextConfigFilename(configPath);
-  const original = readFileSync8(configPath, "utf-8");
+  const original = readFileSync9(configPath, "utf-8");
   let mod;
   try {
     mod = parseModule3(original);
@@ -3530,14 +3696,14 @@ async function installJsxLocPlugin(opts) {
 }
 
 // src/utils/vite-config-inject.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13 } from "path";
+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 = join13(projectPath, `vite.config${ext}`);
-    if (existsSync13(configPath)) return configPath;
+    const configPath = join14(projectPath, `vite.config${ext}`);
+    if (existsSync14(configPath)) return configPath;
   }
   return null;
 }
@@ -3712,7 +3878,7 @@ async function installViteJsxLocPlugin(opts) {
   const configPath = findViteConfigFile2(opts.projectPath);
   if (!configPath) return { configFile: null, modified: false };
   const configFilename = getViteConfigFilename(configPath);
-  const original = readFileSync9(configPath, "utf-8");
+  const original = readFileSync10(configPath, "utf-8");
   const isCjs = configPath.endsWith(".cjs");
   let mod;
   try {
@@ -3741,9 +3907,9 @@ async function installViteJsxLocPlugin(opts) {
 }
 
 // src/utils/next-routes.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var DEV_SOURCE_ROUTE_TS = `/**
  * Dev-only API route for fetching source files
  *
@@ -4199,23 +4365,23 @@ export async function GET(request: NextRequest) {
 }
 `;
 async function writeRouteFile(absPath, relPath, content, opts) {
-  if (existsSync14(absPath) && !opts.force) return;
+  if (existsSync15(absPath) && !opts.force) return;
   await writeFile(absPath, content, "utf-8");
 }
 async function installNextUILintRoutes(opts) {
-  const baseRel = join14(opts.appRoot, "api", ".uilint");
-  const baseAbs = join14(opts.projectPath, baseRel);
-  await mkdir(join14(baseAbs, "source"), { recursive: true });
+  const baseRel = join15(opts.appRoot, "api", ".uilint");
+  const baseAbs = join15(opts.projectPath, baseRel);
+  await mkdir(join15(baseAbs, "source"), { recursive: true });
   await writeRouteFile(
-    join14(baseAbs, "source", "route.ts"),
-    join14(baseRel, "source", "route.ts"),
+    join15(baseAbs, "source", "route.ts"),
+    join15(baseRel, "source", "route.ts"),
     DEV_SOURCE_ROUTE_TS,
     opts
   );
-  await mkdir(join14(baseAbs, "screenshots"), { recursive: true });
+  await mkdir(join15(baseAbs, "screenshots"), { recursive: true });
   await writeRouteFile(
-    join14(baseAbs, "screenshots", "route.ts"),
-    join14(baseRel, "screenshots", "route.ts"),
+    join15(baseAbs, "screenshots", "route.ts"),
+    join15(baseRel, "screenshots", "route.ts"),
     SCREENSHOT_ROUTE_TS,
     opts
   );
@@ -4234,7 +4400,7 @@ async function executeAction(action, options) {
             wouldDo: `Create directory: ${action.path}`
           };
         }
-        if (!existsSync15(action.path)) {
+        if (!existsSync16(action.path)) {
           mkdirSync3(action.path, { recursive: true });
         }
         return { action, success: true };
@@ -4247,8 +4413,8 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname7(action.path);
-        if (!existsSync15(dir)) {
+        const dir = dirname9(action.path);
+        if (!existsSync16(dir)) {
           mkdirSync3(dir, { recursive: true });
         }
         writeFileSync7(action.path, action.content, "utf-8");
@@ -4266,15 +4432,15 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync15(action.path)) {
+        if (existsSync16(action.path)) {
           try {
-            existing = JSON.parse(readFileSync10(action.path, "utf-8"));
+            existing = JSON.parse(readFileSync11(action.path, "utf-8"));
           } catch {
           }
         }
         const merged = deepMerge(existing, action.merge);
-        const dir = dirname7(action.path);
-        if (!existsSync15(dir)) {
+        const dir = dirname9(action.path);
+        if (!existsSync16(dir)) {
           mkdirSync3(dir, { recursive: true });
         }
         writeFileSync7(action.path, JSON.stringify(merged, null, 2), "utf-8");
@@ -4288,7 +4454,7 @@ async function executeAction(action, options) {
             wouldDo: `Delete file: ${action.path}`
           };
         }
-        if (existsSync15(action.path)) {
+        if (existsSync16(action.path)) {
           unlinkSync(action.path);
         }
         return { action, success: true };
@@ -4301,8 +4467,8 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync15(action.path)) {
-          const content = readFileSync10(action.path, "utf-8");
+        if (existsSync16(action.path)) {
+          const content = readFileSync11(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
           }
@@ -4988,7 +5154,7 @@ function displayResults(result) {
   if (summary.nextApp) {
     installedItems.push(
       `${pc.cyan("Next Routes")} \u2192 ${pc.dim(
-        join15(summary.nextApp.appRoot, "api/.uilint")
+        join16(summary.nextApp.appRoot, "api/.uilint")
       )}`
     );
     installedItems.push(
@@ -5123,19 +5289,19 @@ async function install(options = {}, prompter = cliPrompter, executeOptions = {}
 }
 
 // src/commands/serve.ts
-import { existsSync as existsSync17, statSync as statSync4, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname9, resolve as resolve5, relative as relative3, join as join17, parse as parse2 } from "path";
+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 findWorkspaceRoot5,
+  findWorkspaceRoot as findWorkspaceRoot6,
   getVisionAnalyzer as getCoreVisionAnalyzer
 } from "uilint-core/node";
 
 // src/utils/vision-run.ts
-import { dirname as dirname8, join as join16, parse } from "path";
-import { existsSync as existsSync16, statSync as statSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync8 } from "fs";
+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,
@@ -5149,7 +5315,7 @@ async function resolveVisionStyleGuide(args) {
   const startDir = args.startDir ?? projectPath;
   if (args.styleguide) {
     const styleguideArg = resolvePathSpecifier(args.styleguide, projectPath);
-    if (existsSync16(styleguideArg)) {
+    if (existsSync17(styleguideArg)) {
       const stat = statSync3(styleguideArg);
       if (stat.isFile()) {
         return {
@@ -5193,7 +5359,7 @@ function writeVisionDebugDump(params) {
   );
   const safeStamp = params.now.toISOString().replace(/[:.]/g, "-");
   const dumpFile = resolvedDirOrFile.endsWith(".json") || resolvedDirOrFile.endsWith(".jsonl") ? resolvedDirOrFile : `${resolvedDirOrFile}/vision-debug-${safeStamp}.json`;
-  mkdirSync4(dirname8(dumpFile), { recursive: true });
+  mkdirSync4(dirname10(dumpFile), { recursive: true });
   writeFileSync8(
     dumpFile,
     JSON.stringify(
@@ -5282,7 +5448,7 @@ async function runVisionAnalysis(args) {
 }
 function writeVisionMarkdownReport(args) {
   const p2 = parse(args.imagePath);
-  const outPath = args.outPath ?? join16(p2.dir, `${p2.name || p2.base}.vision.md`);
+  const outPath = args.outPath ?? join17(p2.dir, `${p2.name || p2.base}.vision.md`);
   const lines = [];
   lines.push(`# UILint Vision Report`);
   lines.push(``);
@@ -5318,7 +5484,7 @@ function writeVisionMarkdownReport(args) {
   lines.push("```");
   lines.push(``);
   const content = lines.join("\n");
-  mkdirSync4(dirname8(outPath), { recursive: true });
+  mkdirSync4(dirname10(outPath), { recursive: true });
   writeFileSync8(outPath, content, "utf-8");
   return { outPath, content };
 }
@@ -5354,7 +5520,7 @@ var resolvedPathCache = /* @__PURE__ */ new Map();
 var subscriptions = /* @__PURE__ */ new Map();
 var fileWatcher = null;
 var connectedClients = 0;
-var localRequire = createRequire2(import.meta.url);
+var localRequire = createRequire3(import.meta.url);
 function buildLineStarts(code) {
   const starts = [0];
   for (let i = 0; i < code.length; i++) {
@@ -5432,10 +5598,10 @@ function findESLintCwd(startDir) {
   let dir = startDir;
   for (let i = 0; i < 30; i++) {
     for (const cfg of ESLINT_CONFIG_FILES2) {
-      if (existsSync17(join17(dir, cfg))) return dir;
+      if (existsSync18(join18(dir, cfg))) return dir;
     }
-    if (existsSync17(join17(dir, "package.json"))) return dir;
-    const parent = dirname9(dir);
+    if (existsSync18(join18(dir, "package.json"))) return dir;
+    const parent = dirname11(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -5448,7 +5614,7 @@ function normalizeDataLocFilePath(absoluteFilePath, projectCwd) {
   const abs = normalizePathSlashes(resolve5(absoluteFilePath));
   const cwd = normalizePathSlashes(resolve5(projectCwd));
   if (abs === cwd || abs.startsWith(cwd + "/")) {
-    return normalizePathSlashes(relative3(cwd, abs));
+    return normalizePathSlashes(relative4(cwd, abs));
   }
   return abs;
 }
@@ -5460,25 +5626,25 @@ function resolveRequestedFilePath(filePath) {
   if (cached) return cached;
   const cwd = process.cwd();
   const fromCwd = resolve5(cwd, filePath);
-  if (existsSync17(fromCwd)) {
+  if (existsSync18(fromCwd)) {
     resolvedPathCache.set(filePath, fromCwd);
     return fromCwd;
   }
-  const wsRoot = findWorkspaceRoot5(cwd);
+  const wsRoot = findWorkspaceRoot6(cwd);
   const fromWs = resolve5(wsRoot, filePath);
-  if (existsSync17(fromWs)) {
+  if (existsSync18(fromWs)) {
     resolvedPathCache.set(filePath, fromWs);
     return fromWs;
   }
   for (const top of ["apps", "packages"]) {
-    const base = join17(wsRoot, top);
-    if (!existsSync17(base)) continue;
+    const base = join18(wsRoot, top);
+    if (!existsSync18(base)) continue;
     try {
       const entries = readdirSync5(base, { withFileTypes: true });
       for (const ent of entries) {
         if (!ent.isDirectory()) continue;
         const p2 = resolve5(base, ent.name, filePath);
-        if (existsSync17(p2)) {
+        if (existsSync18(p2)) {
           resolvedPathCache.set(filePath, p2);
           return p2;
         }
@@ -5493,7 +5659,7 @@ async function getESLintForProject(projectCwd) {
   const cached = eslintInstances.get(projectCwd);
   if (cached) return cached;
   try {
-    const req = createRequire2(join17(projectCwd, "package.json"));
+    const req = createRequire3(join18(projectCwd, "package.json"));
     const mod = req("eslint");
     const ESLintCtor = mod?.ESLint ?? mod?.default?.ESLint ?? mod?.default ?? mod;
     if (!ESLintCtor) return null;
@@ -5506,7 +5672,7 @@ async function getESLintForProject(projectCwd) {
 }
 async function lintFile(filePath, onProgress) {
   const absolutePath = resolveRequestedFilePath(filePath);
-  if (!existsSync17(absolutePath)) {
+  if (!existsSync18(absolutePath)) {
     onProgress(`File not found: ${pc.dim(absolutePath)}`);
     return [];
   }
@@ -5522,7 +5688,7 @@ async function lintFile(filePath, onProgress) {
     onProgress("Cache hit (unchanged)");
     return cached.issues;
   }
-  const fileDir = dirname9(absolutePath);
+  const fileDir = dirname11(absolutePath);
   const projectCwd = findESLintCwd(fileDir);
   onProgress(`Resolving ESLint project... ${pc.dim(projectCwd)}`);
   const eslint = await getESLintForProject(projectCwd);
@@ -5545,7 +5711,7 @@ async function lintFile(filePath, onProgress) {
     let codeLength = 0;
     try {
       onProgress("Building JSX map...");
-      const code = readFileSync11(absolutePath, "utf-8");
+      const code = readFileSync12(absolutePath, "utf-8");
       codeLength = code.length;
       lineStarts = buildLineStarts(code);
       spans = buildJsxElementSpans(code, dataLocFile);
@@ -5627,9 +5793,9 @@ async function handleMessage(ws, data) {
       });
       const startedAt = Date.now();
       const resolved = resolveRequestedFilePath(filePath);
-      if (!existsSync17(resolved)) {
+      if (!existsSync18(resolved)) {
         const cwd = process.cwd();
-        const wsRoot = findWorkspaceRoot5(cwd);
+        const wsRoot = findWorkspaceRoot6(cwd);
         logWarning(
           [
             `${pc.dim("[ws]")} File not found for request`,
@@ -5789,14 +5955,14 @@ async function handleMessage(ws, data) {
               )}`
             );
           } else {
-            const screenshotsDir = join17(
+            const screenshotsDir = join18(
               serverAppRootForVision,
               ".uilint",
               "screenshots"
             );
-            const imagePath = join17(screenshotsDir, screenshotFile);
+            const imagePath = join18(screenshotsDir, screenshotFile);
             try {
-              if (!existsSync17(imagePath)) {
+              if (!existsSync18(imagePath)) {
                 logWarning(
                   `Skipping vision report write: screenshot file not found ${pc.dim(
                     imagePath
@@ -5904,7 +6070,7 @@ function handleFileChange(filePath) {
 async function serve(options) {
   const port = options.port || 9234;
   const cwd = process.cwd();
-  const wsRoot = findWorkspaceRoot5(cwd);
+  const wsRoot = findWorkspaceRoot6(cwd);
   const appRoot = pickAppRoot({ cwd, workspaceRoot: wsRoot });
   serverAppRootForVision = appRoot;
   logInfo(`Workspace root: ${pc.dim(wsRoot)}`);
@@ -5957,10 +6123,10 @@ async function serve(options) {
 }
 
 // src/commands/vision.ts
-import { dirname as dirname10, resolve as resolve6, join as join18 } from "path";
+import { dirname as dirname12, resolve as resolve6, join as join19 } from "path";
 import {
-  existsSync as existsSync18,
-  readFileSync as readFileSync12,
+  existsSync as existsSync19,
+  readFileSync as readFileSync13,
   readdirSync as readdirSync6
 } from "fs";
 import {
@@ -6006,17 +6172,17 @@ function debugLog3(enabled, message, obj) {
 function findScreenshotsDirUpwards(startDir) {
   let dir = startDir;
   for (let i = 0; i < 20; i++) {
-    const candidate = join18(dir, ".uilint", "screenshots");
-    if (existsSync18(candidate)) return candidate;
-    const parent = dirname10(dir);
+    const candidate = join19(dir, ".uilint", "screenshots");
+    if (existsSync19(candidate)) return candidate;
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function listScreenshotSidecars(dirPath) {
-  if (!existsSync18(dirPath)) return [];
-  const entries = readdirSync6(dirPath).filter((f) => f.endsWith(".json")).map((f) => join18(dirPath, f));
+  if (!existsSync19(dirPath)) return [];
+  const entries = readdirSync6(dirPath).filter((f) => f.endsWith(".json")).map((f) => join19(dirPath, f));
   const out = [];
   for (const p2 of entries) {
     try {
@@ -6045,11 +6211,11 @@ function listScreenshotSidecars(dirPath) {
   return out;
 }
 function readImageAsBase64(imagePath) {
-  const bytes = readFileSync12(imagePath);
+  const bytes = readFileSync13(imagePath);
   return { base64: bytes.toString("base64"), sizeBytes: bytes.byteLength };
 }
 function loadJsonFile(filePath) {
-  const raw = readFileSync12(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   return JSON.parse(raw);
 }
 function formatIssuesText(issues) {
@@ -6123,13 +6289,13 @@ async function vision(options) {
       await flushLangfuse();
       process.exit(1);
     }
-    if (imagePath && !existsSync18(imagePath)) {
+    if (imagePath && !existsSync19(imagePath)) {
       throw new Error(`Image not found: ${imagePath}`);
     }
-    if (sidecarPath && !existsSync18(sidecarPath)) {
+    if (sidecarPath && !existsSync19(sidecarPath)) {
       throw new Error(`Sidecar not found: ${sidecarPath}`);
     }
-    if (manifestFilePath && !existsSync18(manifestFilePath)) {
+    if (manifestFilePath && !existsSync19(manifestFilePath)) {
       throw new Error(`Manifest file not found: ${manifestFilePath}`);
     }
     const sidecar = sidecarPath ? loadJsonFile(sidecarPath) : null;
@@ -6154,7 +6320,7 @@ async function vision(options) {
       const resolved = await resolveVisionStyleGuide({
         projectPath,
         styleguide: options.styleguide,
-        startDir: startPath ? dirname10(startPath) : projectPath
+        startDir: startPath ? dirname12(startPath) : projectPath
       });
       styleGuide = resolved.styleGuide;
       styleguideLocation = resolved.styleguideLocation;
@@ -6203,7 +6369,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 ? dirname10(sidecarPath) : projectPath;
+      const baseDir = sidecarPath ? dirname12(sidecarPath) : projectPath;
       const abs = resolve6(baseDir, screenshotFile);
       return abs;
     })();
@@ -6212,7 +6378,7 @@ async function vision(options) {
         "No image path could be resolved. Provide --image or a sidecar with `screenshotFile`/`filename`."
       );
     }
-    if (!existsSync18(resolvedImagePath)) {
+    if (!existsSync19(resolvedImagePath)) {
       throw new Error(`Image not found: ${resolvedImagePath}`);
     }
     const { base64, sizeBytes } = readImageAsBase64(resolvedImagePath);
@@ -6440,8 +6606,8 @@ async function vision(options) {
 }
 
 // src/commands/session.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
-import { basename, dirname as dirname11, resolve as resolve7 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
+import { basename, dirname as dirname13, resolve as resolve7 } from "path";
 import { createStyleSummary as createStyleSummary3 } from "uilint-core";
 import {
   ensureOllamaReady as ensureOllamaReady7,
@@ -6452,11 +6618,11 @@ import {
 var SESSION_FILE = "/tmp/uilint-session.json";
 var UI_FILE_EXTENSIONS = [".tsx", ".jsx", ".css", ".scss", ".module.css"];
 function readSession() {
-  if (!existsSync19(SESSION_FILE)) {
+  if (!existsSync20(SESSION_FILE)) {
     return { files: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
   try {
-    const content = readFileSync13(SESSION_FILE, "utf-8");
+    const content = readFileSync14(SESSION_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return { files: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -6474,7 +6640,7 @@ function isScannableMarkupFile(filePath) {
   );
 }
 async function sessionClear() {
-  if (existsSync19(SESSION_FILE)) {
+  if (existsSync20(SESSION_FILE)) {
     unlinkSync2(SESSION_FILE);
   }
   console.log(JSON.stringify({ cleared: true }));
@@ -6545,13 +6711,13 @@ async function sessionScan(options = {}) {
   const client = await createLLMClient({});
   const results = [];
   for (const filePath of session.files) {
-    if (!existsSync19(filePath)) continue;
+    if (!existsSync20(filePath)) continue;
     if (!isScannableMarkupFile(filePath)) continue;
     try {
       const absolutePath = resolve7(process.cwd(), filePath);
-      const htmlLike = readFileSync13(filePath, "utf-8");
+      const htmlLike = readFileSync14(filePath, "utf-8");
       const snapshot = parseCLIInput2(htmlLike);
-      const tailwindSearchDir = dirname11(absolutePath);
+      const tailwindSearchDir = dirname13(absolutePath);
       const tailwindTheme = readTailwindThemeTokens3(tailwindSearchDir);
       const styleSummary = createStyleSummary3(snapshot.styles, {
         html: snapshot.html,
@@ -6604,7 +6770,7 @@ async function sessionScan(options = {}) {
     };
     console.log(JSON.stringify(result));
   }
-  if (existsSync19(SESSION_FILE)) {
+  if (existsSync20(SESSION_FILE)) {
     unlinkSync2(SESSION_FILE);
   }
   await flushLangfuse();
@@ -6615,9 +6781,9 @@ async function sessionList() {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname12, join as join19 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname14, join as join20 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function assertNodeVersion(minMajor) {
   const ver = process.versions.node || "";
   const majorStr = ver.split(".")[0] || "";
@@ -6633,9 +6799,9 @@ assertNodeVersion(20);
 var program = new Command();
 function getCLIVersion2() {
   try {
-    const __dirname2 = dirname12(fileURLToPath3(import.meta.url));
-    const pkgPath = join19(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const __dirname3 = dirname14(fileURLToPath4(import.meta.url));
+    const pkgPath = join20(__dirname3, "..", "package.json");
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";