uilint 0.2.23 → 0.2.26

package/dist/{chunk-PB5DLLVC.js → chunk-VNANPKR2.js}

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  detectPackageManager,
+  installDependencies,
+  runTestsWithCoverage
+} from "./chunk-P4I4RKBY.js";
 
 // src/utils/prompts.ts
 import * as p from "@clack/prompts";
@@ -94,38 +99,125 @@ async function multiselect2(options) {
   return handleCancel(result);
 }
 
-// src/utils/next-detect.ts
-import { existsSync, readdirSync } from "fs";
+// 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 existsSync(join2(projectPath, relPath));
+  return existsSync2(join3(projectPath, relPath));
 }
 function detectNextAppRouter(projectPath) {
-  const roots = ["app", join2("src", "app")];
+  const roots = ["app", join3("src", "app")];
   const candidates = [];
   let chosenRoot = null;
   for (const root of roots) {
-    if (existsSync(join2(projectPath, root))) {
+    if (existsSync2(join3(projectPath, root))) {
       chosenRoot = root;
       break;
     }
   }
   if (!chosenRoot) return null;
   const entryCandidates = [
-    join2(chosenRoot, "layout.tsx"),
-    join2(chosenRoot, "layout.jsx"),
-    join2(chosenRoot, "layout.ts"),
-    join2(chosenRoot, "layout.js"),
+    join3(chosenRoot, "layout.tsx"),
+    join3(chosenRoot, "layout.jsx"),
+    join3(chosenRoot, "layout.ts"),
+    join3(chosenRoot, "layout.js"),
     // Fallbacks (less ideal, but can work):
-    join2(chosenRoot, "page.tsx"),
-    join2(chosenRoot, "page.jsx")
+    join3(chosenRoot, "page.tsx"),
+    join3(chosenRoot, "page.jsx")
   ];
   for (const rel of entryCandidates) {
     if (fileExists(projectPath, rel)) candidates.push(rel);
   }
   return {
     appRoot: chosenRoot,
-    appRootAbs: join2(projectPath, chosenRoot),
+    appRootAbs: join3(projectPath, chosenRoot),
     candidates
   };
 }
@@ -169,7 +261,7 @@ function findNextAppRouterProjects(rootDir, options) {
       if (!ent.isDirectory) continue;
       if (ignoreDirs.has(ent.name)) continue;
       if (ent.name.startsWith(".") && ent.name !== ".") continue;
-      walk(join2(dir, ent.name), depth + 1);
+      walk(join3(dir, ent.name), depth + 1);
     }
   }
   walk(rootDir, 0);
@@ -177,15 +269,15 @@ function findNextAppRouterProjects(rootDir, options) {
 }
 
 // src/utils/eslint-config-inject.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join3, relative, dirname as dirname2 } from "path";
+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 = join3(projectPath, `eslint.config${ext}`);
-    if (existsSync2(configPath)) {
+    const configPath = join4(projectPath, `eslint.config${ext}`);
+    if (existsSync3(configPath)) {
       return configPath;
     }
   }
@@ -384,6 +476,15 @@ 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;
@@ -405,22 +506,45 @@ function chooseUniqueIdentifier(base, used) {
   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 = join3(rulesRoot, ".uilint", "rules");
+  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);
-    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
     mod.imports.$add({
       imported: "default",
       local: importName,
@@ -437,7 +561,7 @@ function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot,
     return { importNames, changed };
   }
   const configDir = dirname2(configPath);
-  const rulesDir = join3(rulesRoot, ".uilint", "rules");
+  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);
@@ -596,7 +720,7 @@ async function installEslintPlugin(opts) {
     };
   }
   const configFilename = getEslintConfigFilename(configPath);
-  const original = readFileSync2(configPath, "utf-8");
+  const original = readFileSync3(configPath, "utf-8");
   const isCommonJS = configPath.endsWith(".cjs");
   const ast = getUilintEslintConfigInfoFromSourceAst(original);
   if ("error" in ast) {
@@ -648,10 +772,10 @@ async function installEslintPlugin(opts) {
     };
   }
   let modifiedAst = false;
-  const localRulesDir = join3(opts.projectPath, ".uilint", "rules");
+  const localRulesDir = join4(opts.projectPath, ".uilint", "rules");
   const workspaceRoot = findWorkspaceRoot(opts.projectPath);
-  const workspaceRulesDir = join3(workspaceRoot, ".uilint", "rules");
-  const rulesRoot = existsSync2(localRulesDir) ? opts.projectPath : workspaceRoot;
+  const workspaceRulesDir = join4(workspaceRoot, ".uilint", "rules");
+  const rulesRoot = existsSync3(localRulesDir) ? opts.projectPath : workspaceRoot;
   const isTypeScriptConfig = configPath.endsWith(".ts");
   let fileExtension = isTypeScriptConfig ? "" : ".js";
   let ruleImportNames;
@@ -732,7 +856,7 @@ async function uninstallEslintPlugin(options) {
     };
   }
   try {
-    const original = readFileSync2(configPath, "utf-8");
+    const original = readFileSync3(configPath, "utf-8");
     let updated = original.replace(
       /^import\s+\{[^}]*\}\s+from\s+["'][^"']*\.uilint\/rules[^"']*["'];?\s*$/gm,
       ""
@@ -846,7 +970,7 @@ function extractOptionsFromValueNode(valueNode) {
 function readRuleConfigsFromConfig(configPath) {
   const configs = /* @__PURE__ */ new Map();
   try {
-    const source = readFileSync2(configPath, "utf-8");
+    const source = readFileSync3(configPath, "utf-8");
     const mod = parseModule(source);
     const found = findExportedConfigArrayExpression(mod);
     if (!found) {
@@ -887,7 +1011,7 @@ function findRulePropertyInConfigArray(arrayExpr, ruleId) {
 }
 function updateRuleSeverityInConfig(configPath, ruleId, severity) {
   try {
-    const source = readFileSync2(configPath, "utf-8");
+    const source = readFileSync3(configPath, "utf-8");
     const mod = parseModule(source);
     const found = findExportedConfigArrayExpression(mod);
     if (!found) {
@@ -938,7 +1062,7 @@ function updateRuleSeverityInConfig(configPath, ruleId, severity) {
 }
 function updateRuleConfigInConfig(configPath, ruleId, severity, options) {
   try {
-    const source = readFileSync2(configPath, "utf-8");
+    const source = readFileSync3(configPath, "utf-8");
     const mod = parseModule(source);
     const found = findExportedConfigArrayExpression(mod);
     if (!found) {
@@ -971,6 +1095,104 @@ function updateRuleConfigInConfig(configPath, ruleId, severity, options) {
   }
 }
 
+// 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,
@@ -995,6 +1217,10 @@ export {
   uninstallEslintPlugin,
   readRuleConfigsFromConfig,
   updateRuleSeverityInConfig,
-  updateRuleConfigInConfig
+  updateRuleConfigInConfig,
+  detectCoverageSetup,
+  injectCoverageConfig,
+  prepareCoverage,
+  needsCoveragePreparation
 };
-//# sourceMappingURL=chunk-PB5DLLVC.js.map
+//# sourceMappingURL=chunk-VNANPKR2.js.map