uilint 0.2.22 → 0.2.26

package/dist/chunk-VNANPKR2.js

@@ -0,0 +1,1226 @@
+#!/usr/bin/env node
+import {
+  detectPackageManager,
+  installDependencies,
+  runTestsWithCoverage
+} from "./chunk-P4I4RKBY.js";
+
+// src/utils/prompts.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getCLIVersion() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function intro2(title) {
+  const version = getCLIVersion();
+  const header = pc.bold(pc.cyan("\u25C6 UILint")) + pc.dim(` v${version}`);
+  console.log();
+  p.intro(title ? `${header} ${pc.dim("\xB7")} ${title}` : header);
+}
+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);
+  try {
+    const result = fn.length >= 1 ? await fn(s) : await fn();
+    s.stop(pc.green("\u2713 ") + message);
+    return result;
+  } catch (error) {
+    s.stop(pc.red("\u2717 ") + message);
+    throw error;
+  }
+}
+function createSpinner() {
+  return p.spinner();
+}
+function note2(message, title) {
+  p.note(message, title);
+}
+function log2(message) {
+  p.log.message(message);
+}
+function logInfo(message) {
+  p.log.info(message);
+}
+function logSuccess(message) {
+  p.log.success(message);
+}
+function logWarning(message) {
+  p.log.warn(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 multiselect2(options) {
+  const result = await p.multiselect({
+    message: options.message,
+    options: options.options,
+    required: options.required,
+    initialValues: options.initialValues
+  });
+  return handleCancel(result);
+}
+
+// src/utils/coverage-detect.ts
+import { existsSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2 } from "path";
+var VITEST_CONFIG_FILES = [
+  "vitest.config.ts",
+  "vitest.config.js",
+  "vitest.config.mts",
+  "vitest.config.mjs"
+];
+function checkPackageDeps(projectPath) {
+  try {
+    const pkgPath = join2(projectPath, "package.json");
+    if (!existsSync(pkgPath)) return { hasVitest: false, hasCoveragePackage: false };
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    const hasVitest = "vitest" in deps;
+    const hasCoveragePackage = "@vitest/coverage-v8" in deps || "@vitest/coverage-istanbul" in deps;
+    return { hasVitest, hasCoveragePackage };
+  } catch {
+    return { hasVitest: false, hasCoveragePackage: false };
+  }
+}
+function findVitestConfig(projectPath) {
+  for (const configFile of VITEST_CONFIG_FILES) {
+    const configPath = join2(projectPath, configFile);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function parseCoverageConfig(configPath) {
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    const hasCoverageConfig = /coverage\s*:\s*\{/.test(content);
+    if (!hasCoverageConfig) {
+      return { hasCoverageConfig: false, coverageProvider: null };
+    }
+    const providerMatch = content.match(/provider\s*:\s*["']?(v8|istanbul)["']?/);
+    const coverageProvider = providerMatch ? providerMatch[1] : null;
+    return { hasCoverageConfig, coverageProvider };
+  } catch {
+    return { hasCoverageConfig: false, coverageProvider: null };
+  }
+}
+function findCoverageData(projectPath) {
+  const coverageDataPath = join2(projectPath, "coverage", "coverage-final.json");
+  if (existsSync(coverageDataPath)) {
+    try {
+      const stats = statSync(coverageDataPath);
+      const age = Date.now() - stats.mtimeMs;
+      return { path: coverageDataPath, age };
+    } catch {
+      return { path: coverageDataPath, age: null };
+    }
+  }
+  return { path: null, age: null };
+}
+function detectCoverageSetup(projectPath) {
+  const { hasVitest, hasCoveragePackage } = checkPackageDeps(projectPath);
+  const vitestConfigPath = findVitestConfig(projectPath);
+  const hasVitestConfig = vitestConfigPath !== null;
+  let hasCoverageConfig = false;
+  let coverageProvider = null;
+  if (vitestConfigPath) {
+    const coverageInfo = parseCoverageConfig(vitestConfigPath);
+    hasCoverageConfig = coverageInfo.hasCoverageConfig;
+    coverageProvider = coverageInfo.coverageProvider;
+  }
+  const coverageData = findCoverageData(projectPath);
+  const hasCoverageData = coverageData.path !== null;
+  const needsCoveragePackage = hasVitest && !hasCoveragePackage;
+  const needsCoverageConfig = hasVitest && hasVitestConfig && !hasCoverageConfig;
+  return {
+    hasVitest,
+    hasVitestConfig,
+    vitestConfigPath,
+    hasCoverageConfig,
+    coverageProvider,
+    hasCoverageData,
+    coverageDataPath: coverageData.path,
+    needsCoveragePackage,
+    needsCoverageConfig,
+    coverageDataAge: coverageData.age
+  };
+}
+
+// src/utils/next-detect.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join3 } from "path";
+function fileExists(projectPath, relPath) {
+  return existsSync2(join3(projectPath, relPath));
+}
+function detectNextAppRouter(projectPath) {
+  const roots = ["app", join3("src", "app")];
+  const candidates = [];
+  let chosenRoot = null;
+  for (const root of roots) {
+    if (existsSync2(join3(projectPath, root))) {
+      chosenRoot = root;
+      break;
+    }
+  }
+  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);
+  }
+  return {
+    appRoot: chosenRoot,
+    appRootAbs: join3(projectPath, chosenRoot),
+    candidates
+  };
+}
+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;
+}
+
+// src/utils/eslint-config-inject.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join4, relative, dirname as dirname2 } from "path";
+import { parseExpression, parseModule, generateCode } from "magicast";
+import { findWorkspaceRoot } from "uilint-core/node";
+var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
+function findEslintConfigFile(projectPath) {
+  for (const ext of CONFIG_EXTENSIONS) {
+    const configPath = join4(projectPath, `eslint.config${ext}`);
+    if (existsSync3(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 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 resolveTopLevelIdentifierToArrayExpr(program2, name) {
+    if (!program2 || program2.type !== "Program") return null;
+    for (const stmt of program2.body ?? []) {
+      if (stmt?.type !== "VariableDeclaration") continue;
+      for (const decl of stmt.declarations ?? []) {
+        const id = decl?.id;
+        if (!isIdentifier(id, name)) continue;
+        const init = unwrapExpression(decl?.init);
+        if (!init) return null;
+        if (init.type === "ArrayExpression") return init;
+        if (init.type === "CallExpression" && isIdentifier(init.callee, "defineConfig") && unwrapExpression(init.arguments?.[0])?.type === "ArrayExpression") {
+          return unwrapExpression(init.arguments?.[0]);
+        }
+        return null;
+      }
+    }
+    return null;
+  }
+  const program = mod?.$ast;
+  if (program && program.type === "Program") {
+    for (const stmt of program.body ?? []) {
+      if (!stmt || stmt.type !== "ExportDefaultDeclaration") continue;
+      const decl = unwrapExpression(stmt.declaration);
+      if (!decl) break;
+      if (decl.type === "ArrayExpression") {
+        return { kind: "esm", arrayExpr: decl, program };
+      }
+      if (decl.type === "CallExpression" && isIdentifier(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ArrayExpression") {
+        return {
+          kind: "esm",
+          arrayExpr: unwrapExpression(decl.arguments?.[0]),
+          program
+        };
+      }
+      if (decl.type === "Identifier" && typeof decl.name === "string") {
+        const resolved = resolveTopLevelIdentifierToArrayExpr(
+          program,
+          decl.name
+        );
+        if (resolved) return { kind: "esm", arrayExpr: resolved, program };
+      }
+      break;
+    }
+  }
+  if (!program || program.type !== "Program") return null;
+  for (const stmt of program.body ?? []) {
+    if (!stmt || stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (!expr || expr.type !== "AssignmentExpression") continue;
+    const left = expr.left;
+    const right = expr.right;
+    const isModuleExports = left?.type === "MemberExpression" && isIdentifier(left.object, "module") && isIdentifier(left.property, "exports");
+    if (!isModuleExports) continue;
+    if (right?.type === "ArrayExpression") {
+      return { kind: "cjs", arrayExpr: right, program };
+    }
+    if (right?.type === "CallExpression" && isIdentifier(right.callee, "defineConfig") && right.arguments?.[0]?.type === "ArrayExpression") {
+      return { kind: "cjs", arrayExpr: right.arguments[0], program };
+    }
+    if (right?.type === "Identifier" && typeof right.name === "string") {
+      const resolved = resolveTopLevelIdentifierToArrayExpr(
+        program,
+        right.name
+      );
+      if (resolved) return { kind: "cjs", arrayExpr: resolved, program };
+    }
+  }
+  return null;
+}
+function collectConfiguredUilintRuleIdsFromConfigArray(arrayExpr) {
+  const ids = /* @__PURE__ */ new Set();
+  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return ids;
+  for (const el of arrayExpr.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const rules = getObjectPropertyValue(el, "rules");
+    for (const id of collectUilintRuleIdsFromRulesObject(rules)) ids.add(id);
+  }
+  return ids;
+}
+function findExistingUilintRulesObject(arrayExpr) {
+  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") {
+    return { configObj: null, rulesObj: null, safeToMutate: false };
+  }
+  for (const el of arrayExpr.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const plugins = getObjectPropertyValue(el, "plugins");
+    const rules = getObjectPropertyValue(el, "rules");
+    const hasUilintPlugin = plugins?.type === "ObjectExpression" && getObjectPropertyValue(plugins, "uilint") !== null;
+    const uilintIds = collectUilintRuleIdsFromRulesObject(rules);
+    const hasUilintRules = uilintIds.size > 0;
+    if (!hasUilintPlugin && !hasUilintRules) continue;
+    const safe = rules?.type === "ObjectExpression" && !hasSpreadProperties(rules);
+    return { configObj: el, rulesObj: rules, safeToMutate: safe };
+  }
+  return { configObj: null, rulesObj: null, safeToMutate: false };
+}
+function collectTopLevelBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  if (!program || program.type !== "Program") return names;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type === "ImportDeclaration") {
+      for (const spec of stmt.specifiers ?? []) {
+        const local = spec?.local;
+        if (local?.type === "Identifier" && typeof local.name === "string") {
+          names.add(local.name);
+        }
+      }
+      continue;
+    }
+    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 findExistingDefaultImportLocalName(program, from) {
+  if (!program || program.type !== "Program") return null;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ImportDeclaration") continue;
+    const src = stmt.source?.value;
+    if (typeof src !== "string" || src !== from) continue;
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec?.type === "ImportDefaultSpecifier") {
+        const local = spec.local;
+        if (local?.type === "Identifier" && typeof local.name === "string") {
+          return local.name;
+        }
+      }
+    }
+  }
+  return null;
+}
+function addLocalRuleImportsAst(mod, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
+  const importNames = /* @__PURE__ */ new Map();
+  let changed = false;
+  const configDir = dirname2(configPath);
+  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative(configDir, rulesDir).replace(/\\/g, "/");
+  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
+  const used = collectTopLevelBindings(mod.$ast);
+  for (const rule of selectedRules) {
+    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
+    const existingLocal = findExistingDefaultImportLocalName(mod.$ast, rulePath);
+    if (existingLocal) {
+      importNames.set(rule.id, existingLocal);
+      used.add(existingLocal);
+      continue;
+    }
+    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);
+    mod.imports.$add({
+      imported: "default",
+      local: importName,
+      from: rulePath
+    });
+    changed = true;
+  }
+  return { importNames, changed };
+}
+function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
+  const importNames = /* @__PURE__ */ new Map();
+  let changed = false;
+  if (!program || program.type !== "Program") {
+    return { importNames, changed };
+  }
+  const configDir = dirname2(configPath);
+  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative(configDir, rulesDir).replace(/\\/g, "/");
+  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
+  const used = collectTopLevelBindings(program);
+  for (const rule of selectedRules) {
+    const importName = chooseUniqueIdentifier(
+      `${rule.id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase())}Rule`,
+      used
+    );
+    importNames.set(rule.id, importName);
+    used.add(importName);
+    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
+    const stmtMod = parseModule(
+      `const ${importName} = require("${rulePath}");`
+    );
+    const stmt = stmtMod.$ast.body?.[0];
+    if (stmt) {
+      let insertAt = 0;
+      const first = program.body?.[0];
+      if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
+        insertAt = 1;
+      }
+      program.body.splice(insertAt, 0, stmt);
+      changed = true;
+    }
+  }
+  return { importNames, changed };
+}
+function appendUilintConfigBlockToArray(arrayExpr, selectedRules, ruleImportNames) {
+  const pluginRulesCode = Array.from(ruleImportNames.entries()).map(([ruleId, importName]) => `      "${ruleId}": ${importName},`).join("\n");
+  const rulesPropsCode = selectedRules.map((r) => {
+    const ruleKey = `uilint/${r.id}`;
+    const valueCode = r.defaultOptions && r.defaultOptions.length > 0 ? `["${r.defaultSeverity}", ...${JSON.stringify(
+      r.defaultOptions,
+      null,
+      2
+    )}]` : `"${r.defaultSeverity}"`;
+    return `      "${ruleKey}": ${valueCode},`;
+  }).join("\n");
+  const blockCode = `{
+    files: [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "app/**/*.{js,jsx,ts,tsx}",
+      "pages/**/*.{js,jsx,ts,tsx}",
+    ],
+    plugins: {
+      uilint: {
+        rules: {
+${pluginRulesCode}
+        },
+      },
+    },
+    rules: {
+${rulesPropsCode}
+    },
+  }`;
+  const objExpr = parseExpression(blockCode).$ast;
+  arrayExpr.elements.push(objExpr);
+}
+function getUilintEslintConfigInfoFromSourceAst(source) {
+  try {
+    const mod = parseModule(source);
+    const found = findExportedConfigArrayExpression(mod);
+    if (!found) {
+      return {
+        error: "Could not locate an exported ESLint flat config array (expected `export default [...]`, `export default defineConfig([...])`, `module.exports = [...]`, or `module.exports = defineConfig([...])`)."
+      };
+    }
+    const configuredRuleIds = collectConfiguredUilintRuleIdsFromConfigArray(
+      found.arrayExpr
+    );
+    const existingUilint = findExistingUilintRulesObject(found.arrayExpr);
+    const configured = configuredRuleIds.size > 0 || existingUilint.configObj !== null;
+    return {
+      info: { configuredRuleIds, configured },
+      mod,
+      arrayExpr: found.arrayExpr,
+      kind: found.kind
+    };
+  } catch {
+    return {
+      error: "Unable to parse ESLint config as JavaScript. Please update it manually or simplify the config so it can be safely auto-modified."
+    };
+  }
+}
+function getUilintEslintConfigInfoFromSource(source) {
+  const ast = getUilintEslintConfigInfoFromSourceAst(source);
+  if ("error" in ast) {
+    const configuredRuleIds = extractConfiguredUilintRuleIds(source);
+    return {
+      configuredRuleIds,
+      configured: configuredRuleIds.size > 0
+    };
+  }
+  return ast.info;
+}
+function extractConfiguredUilintRuleIds(source) {
+  const ids = /* @__PURE__ */ new Set();
+  const re = /["']uilint\/([^"']+)["']\s*:/g;
+  for (const m of source.matchAll(re)) {
+    if (m[1]) ids.add(m[1]);
+  }
+  return ids;
+}
+function getMissingSelectedRules(selectedRules, configuredIds) {
+  return selectedRules.filter((r) => !configuredIds.has(r.id));
+}
+function buildDesiredRuleValueExpression(rule) {
+  if (rule.defaultOptions && rule.defaultOptions.length > 0) {
+    return `["${rule.defaultSeverity}", ...${JSON.stringify(
+      rule.defaultOptions,
+      null,
+      2
+    )}]`;
+  }
+  return `"${rule.defaultSeverity}"`;
+}
+function collectUilintRuleValueNodesFromConfigArray(arrayExpr) {
+  const out = /* @__PURE__ */ new Map();
+  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return out;
+  for (const el of arrayExpr.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const rules = getObjectPropertyValue(el, "rules");
+    if (!rules || rules.type !== "ObjectExpression") continue;
+    for (const prop of rules.properties ?? []) {
+      if (!prop) continue;
+      if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+      const key = prop.key;
+      if (!isStringLiteral(key)) continue;
+      const k = key.value;
+      if (typeof k !== "string" || !k.startsWith("uilint/")) continue;
+      const id = k.slice("uilint/".length);
+      if (!out.has(id)) out.set(id, prop.value);
+    }
+  }
+  return out;
+}
+function getRulesNeedingUpdate(selectedRules, configuredIds, arrayExpr) {
+  const existingVals = collectUilintRuleValueNodesFromConfigArray(arrayExpr);
+  return selectedRules.filter((r) => {
+    if (!configuredIds.has(r.id)) return false;
+    const existing = existingVals.get(r.id);
+    if (!existing) return true;
+    const desiredExpr = buildDesiredRuleValueExpression(r);
+    const desiredAst = parseExpression(desiredExpr).$ast;
+    return !astEquivalent(existing, desiredAst);
+  });
+}
+async function installEslintPlugin(opts) {
+  const configPath = findEslintConfigFile(opts.projectPath);
+  if (!configPath) {
+    return {
+      configFile: null,
+      modified: false,
+      missingRuleIds: [],
+      configured: false
+    };
+  }
+  const configFilename = getEslintConfigFilename(configPath);
+  const original = readFileSync3(configPath, "utf-8");
+  const isCommonJS = configPath.endsWith(".cjs");
+  const ast = getUilintEslintConfigInfoFromSourceAst(original);
+  if ("error" in ast) {
+    return {
+      configFile: configFilename,
+      modified: false,
+      missingRuleIds: [],
+      configured: false,
+      error: ast.error
+    };
+  }
+  const { info, mod, arrayExpr, kind } = ast;
+  const configuredIds = info.configuredRuleIds;
+  const missingRules = getMissingSelectedRules(
+    opts.selectedRules,
+    configuredIds
+  );
+  const rulesToUpdate = getRulesNeedingUpdate(
+    opts.selectedRules,
+    configuredIds,
+    arrayExpr
+  );
+  let rulesToApply = [];
+  if (!info.configured) {
+    rulesToApply = opts.selectedRules;
+  } else {
+    rulesToApply = [...missingRules, ...rulesToUpdate];
+    if (missingRules.length > 0 && !opts.force) {
+      const ok = await opts.confirmAddMissingRules?.(
+        configFilename,
+        missingRules
+      );
+      if (!ok) {
+        return {
+          configFile: configFilename,
+          modified: false,
+          missingRuleIds: missingRules.map((r) => r.id),
+          configured: true
+        };
+      }
+    }
+  }
+  if (rulesToApply.length === 0) {
+    return {
+      configFile: configFilename,
+      modified: false,
+      missingRuleIds: missingRules.map((r) => r.id),
+      configured: info.configured
+    };
+  }
+  let modifiedAst = false;
+  const localRulesDir = join4(opts.projectPath, ".uilint", "rules");
+  const workspaceRoot = findWorkspaceRoot(opts.projectPath);
+  const workspaceRulesDir = join4(workspaceRoot, ".uilint", "rules");
+  const rulesRoot = existsSync3(localRulesDir) ? opts.projectPath : workspaceRoot;
+  const isTypeScriptConfig = configPath.endsWith(".ts");
+  let fileExtension = isTypeScriptConfig ? "" : ".js";
+  let ruleImportNames;
+  if (kind === "esm") {
+    const result = addLocalRuleImportsAst(
+      mod,
+      rulesToApply,
+      configPath,
+      rulesRoot,
+      fileExtension
+    );
+    ruleImportNames = result.importNames;
+    if (result.changed) modifiedAst = true;
+  } else {
+    const result = addLocalRuleRequiresAst(
+      mod.$ast,
+      rulesToApply,
+      configPath,
+      rulesRoot,
+      fileExtension
+    );
+    ruleImportNames = result.importNames;
+    if (result.changed) modifiedAst = true;
+  }
+  if (ruleImportNames && ruleImportNames.size > 0) {
+    appendUilintConfigBlockToArray(arrayExpr, rulesToApply, ruleImportNames);
+    modifiedAst = true;
+  }
+  if (!info.configured) {
+    if (kind === "esm") {
+      mod.imports.$add({
+        imported: "createRule",
+        local: "createRule",
+        from: "uilint-eslint"
+      });
+      modifiedAst = true;
+    } else {
+      const stmtMod = parseModule(
+        `const { createRule } = require("uilint-eslint");`
+      );
+      const stmt = stmtMod.$ast.body?.[0];
+      if (stmt) {
+        let insertAt = 0;
+        const first = mod.$ast.body?.[0];
+        if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
+          insertAt = 1;
+        }
+        mod.$ast.body.splice(insertAt, 0, stmt);
+        modifiedAst = true;
+      }
+    }
+  }
+  const updated = modifiedAst ? generateCode(mod).code : original;
+  if (updated !== original) {
+    writeFileSync(configPath, updated, "utf-8");
+    return {
+      configFile: configFilename,
+      modified: true,
+      missingRuleIds: missingRules.map((r) => r.id),
+      configured: getUilintEslintConfigInfoFromSource(updated).configured
+    };
+  }
+  return {
+    configFile: configFilename,
+    modified: false,
+    missingRuleIds: missingRules.map((r) => r.id),
+    configured: getUilintEslintConfigInfoFromSource(updated).configured
+  };
+}
+async function uninstallEslintPlugin(options) {
+  const { projectPath } = options;
+  const configPath = findEslintConfigFile(projectPath);
+  if (!configPath) {
+    return {
+      success: true,
+      // Nothing to uninstall
+      modifiedFiles: []
+    };
+  }
+  try {
+    const original = readFileSync3(configPath, "utf-8");
+    let updated = original.replace(
+      /^import\s+\{[^}]*\}\s+from\s+["'][^"']*\.uilint\/rules[^"']*["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^import\s+\w+\s+from\s+["'][^"']*\.uilint\/rules[^"']*["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^import\s+\{[^}]*\}\s+from\s+["']uilint-eslint["'];?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /^const\s+\{[^}]*createRule[^}]*\}\s*=\s*require\s*\(\s*["']uilint-eslint["']\s*\)\s*;?\s*$/gm,
+      ""
+    );
+    updated = updated.replace(
+      /["']uilint\/[^"']+["']\s*:\s*["'][^"']+["']\s*,?\s*/g,
+      ""
+    );
+    updated = updated.replace(
+      /["']uilint\/[^"']+["']\s*:\s*\[[^\]]*\]\s*,?\s*/g,
+      ""
+    );
+    updated = updated.replace(
+      /\{\s*plugins:\s*\{\s*uilint:\s*\{[^}]*\}[^}]*\}[^}]*rules:\s*\{[^}]*\}[^}]*\}\s*,?\s*/gs,
+      ""
+    );
+    updated = updated.replace(/\n{3,}/g, "\n\n");
+    if (updated !== original) {
+      writeFileSync(configPath, updated, "utf-8");
+      return {
+        success: true,
+        modifiedFiles: [configPath]
+      };
+    }
+    return {
+      success: true,
+      modifiedFiles: []
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function extractSeverityFromValueNode(valueNode) {
+  if (!valueNode) return null;
+  if (isStringLiteral(valueNode)) {
+    const val = valueNode.value;
+    if (val === "error" || val === "warn" || val === "off") {
+      return val;
+    }
+    return null;
+  }
+  if (valueNode.type === "ArrayExpression") {
+    const firstEl = valueNode.elements?.[0];
+    if (firstEl && isStringLiteral(firstEl)) {
+      const val = firstEl.value;
+      if (val === "error" || val === "warn" || val === "off") {
+        return val;
+      }
+    }
+  }
+  return null;
+}
+function extractOptionsFromValueNode(valueNode) {
+  if (!valueNode || valueNode.type !== "ArrayExpression") return void 0;
+  const elements = valueNode.elements ?? [];
+  if (elements.length < 2) return void 0;
+  const optionsNode = elements[1];
+  if (!optionsNode || optionsNode.type !== "ObjectExpression") return void 0;
+  try {
+    const obj = {};
+    for (const prop of optionsNode.properties ?? []) {
+      if (!prop || prop.type !== "ObjectProperty" && prop.type !== "Property")
+        continue;
+      const key = prop.key;
+      let keyName = null;
+      if (key?.type === "Identifier") {
+        keyName = key.name;
+      } else if (isStringLiteral(key)) {
+        keyName = key.value;
+      }
+      if (!keyName) continue;
+      const val = prop.value;
+      if (isStringLiteral(val)) {
+        obj[keyName] = val.value;
+      } else if (val?.type === "NumericLiteral" || val?.type === "Literal" && typeof val.value === "number") {
+        obj[keyName] = val.value;
+      } else if (val?.type === "BooleanLiteral" || val?.type === "Literal" && typeof val.value === "boolean") {
+        obj[keyName] = val.value;
+      } else if (val?.type === "ArrayExpression") {
+        const arr = [];
+        for (const el of val.elements ?? []) {
+          if (isStringLiteral(el)) arr.push(el.value);
+          else if (el?.type === "NumericLiteral" || el?.type === "Literal" && typeof el.value === "number")
+            arr.push(el.value);
+          else if (el?.type === "BooleanLiteral" || el?.type === "Literal" && typeof el.value === "boolean")
+            arr.push(el.value);
+        }
+        obj[keyName] = arr;
+      }
+    }
+    return Object.keys(obj).length > 0 ? obj : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readRuleConfigsFromConfig(configPath) {
+  const configs = /* @__PURE__ */ new Map();
+  try {
+    const source = readFileSync3(configPath, "utf-8");
+    const mod = parseModule(source);
+    const found = findExportedConfigArrayExpression(mod);
+    if (!found) {
+      return configs;
+    }
+    const { arrayExpr } = found;
+    const valueNodes = collectUilintRuleValueNodesFromConfigArray(arrayExpr);
+    for (const [ruleId, valueNode] of valueNodes) {
+      const severity = extractSeverityFromValueNode(valueNode);
+      if (severity) {
+        const options = extractOptionsFromValueNode(valueNode);
+        configs.set(ruleId, { severity, options });
+      }
+    }
+  } catch (error) {
+    console.error("[eslint-config-inject] Failed to read rule configs:", error);
+  }
+  return configs;
+}
+function findRulePropertyInConfigArray(arrayExpr, ruleId) {
+  const fullRuleKey = `uilint/${ruleId}`;
+  if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return null;
+  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;
+      if (key.value === fullRuleKey) {
+        return { prop, rulesObj: rules };
+      }
+    }
+  }
+  return null;
+}
+function updateRuleSeverityInConfig(configPath, ruleId, severity) {
+  try {
+    const source = readFileSync3(configPath, "utf-8");
+    const mod = parseModule(source);
+    const found = findExportedConfigArrayExpression(mod);
+    if (!found) {
+      return {
+        success: false,
+        error: "Could not parse ESLint config array"
+      };
+    }
+    const { arrayExpr } = found;
+    const ruleInfo = findRulePropertyInConfigArray(arrayExpr, ruleId);
+    if (!ruleInfo) {
+      return {
+        success: false,
+        error: `Rule "uilint/${ruleId}" not found in config. Use 'uilint install' to add new rules.`
+      };
+    }
+    const { prop } = ruleInfo;
+    const valueNode = prop.value;
+    if (isStringLiteral(valueNode)) {
+      valueNode.value = severity;
+    } else if (valueNode?.type === "ArrayExpression") {
+      const firstEl = valueNode.elements?.[0];
+      if (firstEl && isStringLiteral(firstEl)) {
+        firstEl.value = severity;
+      } else {
+        const severityNode = parseExpression(`"${severity}"`).$ast;
+        if (valueNode.elements && valueNode.elements.length > 0) {
+          valueNode.elements[0] = severityNode;
+        } else {
+          valueNode.elements = [severityNode];
+        }
+      }
+    } else {
+      return {
+        success: false,
+        error: `Rule "uilint/${ruleId}" has unexpected format`
+      };
+    }
+    const updated = generateCode(mod).code;
+    writeFileSync(configPath, updated, "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function updateRuleConfigInConfig(configPath, ruleId, severity, options) {
+  try {
+    const source = readFileSync3(configPath, "utf-8");
+    const mod = parseModule(source);
+    const found = findExportedConfigArrayExpression(mod);
+    if (!found) {
+      return {
+        success: false,
+        error: "Could not parse ESLint config array"
+      };
+    }
+    const { arrayExpr } = found;
+    const ruleInfo = findRulePropertyInConfigArray(arrayExpr, ruleId);
+    if (!ruleInfo) {
+      return {
+        success: false,
+        error: `Rule "uilint/${ruleId}" not found in config. Use 'uilint install' to add new rules.`
+      };
+    }
+    const { prop } = ruleInfo;
+    const optionsJson = JSON.stringify(options);
+    const newValueExpr = `["${severity}", ${optionsJson}]`;
+    const newValueNode = parseExpression(newValueExpr).$ast;
+    prop.value = newValueNode;
+    const updated = generateCode(mod).code;
+    writeFileSync(configPath, updated, "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/utils/coverage-prepare.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+function injectCoverageConfig(vitestConfigPath) {
+  try {
+    const content = readFileSync4(vitestConfigPath, "utf-8");
+    if (/coverage\s*:\s*\{/.test(content)) {
+      return false;
+    }
+    const testBlockRegex = /(test\s*:\s*\{)/;
+    const match = content.match(testBlockRegex);
+    if (!match) {
+      return false;
+    }
+    const coverageConfig = `
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json"],
+      reportsDirectory: "./coverage",
+    },`;
+    const newContent = content.replace(
+      testBlockRegex,
+      `$1${coverageConfig}`
+    );
+    writeFileSync2(vitestConfigPath, newContent, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function prepareCoverage(options) {
+  const { appRoot, onProgress, skipPackageInstall, skipTests } = options;
+  const start = Date.now();
+  const result = {
+    packageAdded: false,
+    configModified: false,
+    testsRan: false,
+    coverageGenerated: false,
+    duration: 0
+  };
+  try {
+    onProgress?.("Detecting coverage setup...", "detect");
+    const setup = detectCoverageSetup(appRoot);
+    if (!setup.hasVitest) {
+      result.error = "Vitest not found in dependencies";
+      result.duration = Date.now() - start;
+      return result;
+    }
+    if (setup.needsCoveragePackage && !skipPackageInstall) {
+      onProgress?.("Installing @vitest/coverage-v8...", "install");
+      const pm = detectPackageManager(appRoot);
+      try {
+        await installDependencies(pm, appRoot, ["@vitest/coverage-v8"]);
+        result.packageAdded = true;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        result.error = `Failed to install coverage package: ${msg}`;
+        result.duration = Date.now() - start;
+        return result;
+      }
+    }
+    if (setup.needsCoverageConfig && setup.vitestConfigPath) {
+      onProgress?.("Adding coverage configuration...", "config");
+      result.configModified = injectCoverageConfig(setup.vitestConfigPath);
+    }
+    if (!skipTests) {
+      const updatedSetup = detectCoverageSetup(appRoot);
+      if (!updatedSetup.hasCoverageData || result.configModified) {
+        onProgress?.("Running tests with coverage...", "test");
+        const pm = detectPackageManager(appRoot);
+        try {
+          await runTestsWithCoverage(pm, appRoot);
+          result.testsRan = true;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          result.error = `Tests failed: ${msg}`;
+        }
+        const finalSetup = detectCoverageSetup(appRoot);
+        result.coverageGenerated = finalSetup.hasCoverageData;
+      }
+    } else {
+      onProgress?.("Skipping tests (skipTests=true)", "skip");
+    }
+    result.duration = Date.now() - start;
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    result.error = `Coverage preparation failed: ${msg}`;
+    result.duration = Date.now() - start;
+    return result;
+  }
+}
+function needsCoveragePreparation(setup) {
+  if (!setup.hasVitest) {
+    return false;
+  }
+  return setup.needsCoveragePackage || setup.needsCoverageConfig || !setup.hasCoverageData;
+}
+
+export {
+  pc,
+  intro2 as intro,
+  outro2 as outro,
+  withSpinner,
+  createSpinner,
+  note2 as note,
+  log2 as log,
+  logInfo,
+  logSuccess,
+  logWarning,
+  logError,
+  select2 as select,
+  confirm2 as confirm,
+  multiselect2 as multiselect,
+  detectNextAppRouter,
+  findNextAppRouterProjects,
+  findEslintConfigFile,
+  getEslintConfigFilename,
+  getUilintEslintConfigInfoFromSource,
+  installEslintPlugin,
+  uninstallEslintPlugin,
+  readRuleConfigsFromConfig,
+  updateRuleSeverityInConfig,
+  updateRuleConfigInConfig,
+  detectCoverageSetup,
+  injectCoverageConfig,
+  prepareCoverage,
+  needsCoveragePreparation
+};
+//# sourceMappingURL=chunk-VNANPKR2.js.map