uilint 0.2.23 → 0.2.26

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   createSpinner,
+  detectCoverageSetup,
   detectNextAppRouter,
   findEslintConfigFile,
   findNextAppRouterProjects,
@@ -9,17 +10,20 @@ import {
   logInfo,
   logSuccess,
   logWarning,
+  needsCoveragePreparation,
   note,
   outro,
   pc,
+  prepareCoverage,
   readRuleConfigsFromConfig,
   updateRuleConfigInConfig,
   updateRuleSeverityInConfig,
   withSpinner
-} from "./chunk-PB5DLLVC.js";
+} from "./chunk-VNANPKR2.js";
+import "./chunk-P4I4RKBY.js";
 
 // src/index.ts
-import { Command } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/scan.ts
 import { dirname, resolve as resolve2 } from "path";
@@ -255,8 +259,8 @@ async function initializeLangfuseIfEnabled() {
               },
               { asType: "generation" }
             );
-            await new Promise((resolve7) => {
-              resolveTrace = resolve7;
+            await new Promise((resolve8) => {
+              resolveTrace = resolve8;
             });
             if (endData && generationRef) {
               const usageDetails = endData.usage ? Object.fromEntries(
@@ -1172,14 +1176,14 @@ import {
 } from "uilint-core";
 import { ensureOllamaReady as ensureOllamaReady3 } from "uilint-core/node";
 async function readStdin2() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let data = "";
     const rl = createInterface({ input: process.stdin });
     rl.on("line", (line) => {
       data += line;
     });
     rl.on("close", () => {
-      resolve7(data);
+      resolve8(data);
     });
   });
 }
@@ -2163,6 +2167,37 @@ ${stack}` : ""
       handleRuleConfigSet(ws, ruleId, severity, options, requestId);
       break;
     }
+    case "coverage:request": {
+      const { requestId } = message;
+      try {
+        const coveragePath = join3(serverAppRootForVision, "coverage", "coverage-final.json");
+        if (!existsSync5(coveragePath)) {
+          sendMessage(ws, {
+            type: "coverage:error",
+            error: "Coverage data not found. Run tests with coverage first (e.g., `vitest run --coverage`)",
+            requestId
+          });
+          break;
+        }
+        const coverageData = JSON.parse(readFileSync(coveragePath, "utf-8"));
+        logInfo(`${pc.dim("[ws]")} coverage:result ${pc.dim(`${Object.keys(coverageData).length} files`)}`);
+        sendMessage(ws, {
+          type: "coverage:result",
+          coverage: coverageData,
+          timestamp: Date.now(),
+          requestId
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`${pc.dim("[ws]")} coverage:error ${errorMessage}`);
+        sendMessage(ws, {
+          type: "coverage:error",
+          error: errorMessage,
+          requestId
+        });
+      }
+      break;
+    }
   }
 }
 function handleDisconnect(ws) {
@@ -2188,6 +2223,24 @@ function handleFileChange(filePath) {
     sendMessage(ws, { type: "file:changed", filePath: clientFilePath });
   }
 }
+function handleCoverageFileChange(filePath) {
+  try {
+    const coverageData = JSON.parse(readFileSync(filePath, "utf-8"));
+    logInfo(`${pc.dim("[ws]")} coverage:changed ${pc.dim(`${Object.keys(coverageData).length} files`)}`);
+    broadcast({
+      type: "coverage:result",
+      coverage: coverageData,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logError(`${pc.dim("[ws]")} Failed to read coverage data: ${errorMessage}`);
+    broadcast({
+      type: "coverage:error",
+      error: `Failed to read coverage: ${errorMessage}`
+    });
+  }
+}
 var configStore = /* @__PURE__ */ new Map();
 var connectedClientsSet = /* @__PURE__ */ new Set();
 function broadcastConfigUpdate(key, value) {
@@ -2212,6 +2265,127 @@ function broadcastRuleConfigChange(ruleId, severity, options) {
     sendMessage(ws, message);
   }
 }
+function broadcast(message) {
+  for (const ws of connectedClientsSet) {
+    sendMessage(ws, message);
+  }
+}
+var isIndexing = false;
+var reindexTimeout = null;
+var pendingIndexChanges = /* @__PURE__ */ new Set();
+async function buildDuplicatesIndex(appRoot) {
+  if (isIndexing) {
+    return;
+  }
+  isIndexing = true;
+  logInfo(`${pc.blue("Building duplicates index...")}`);
+  broadcast({ type: "duplicates:indexing:start" });
+  try {
+    const { indexDirectory } = await import("uilint-duplicates");
+    const result = await indexDirectory(appRoot, {
+      onProgress: (message, current, total) => {
+        if (current !== void 0 && total !== void 0) {
+          logInfo(`  ${message} (${current}/${total})`);
+        } else {
+          logInfo(`  ${message}`);
+        }
+        broadcast({
+          type: "duplicates:indexing:progress",
+          message,
+          current,
+          total
+        });
+      }
+    });
+    logSuccess(
+      `${pc.green("Index complete:")} ${result.totalChunks} chunks (${result.added} added, ${result.modified} modified, ${result.deleted} deleted) in ${(result.duration / 1e3).toFixed(1)}s`
+    );
+    broadcast({
+      type: "duplicates:indexing:complete",
+      added: result.added,
+      modified: result.modified,
+      deleted: result.deleted,
+      totalChunks: result.totalChunks,
+      duration: result.duration
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logError(`Index failed: ${msg}`);
+    broadcast({ type: "duplicates:indexing:error", error: msg });
+  } finally {
+    isIndexing = false;
+  }
+}
+function scheduleReindex(appRoot, filePath) {
+  if (!/\.(tsx?|jsx?)$/.test(filePath)) return;
+  pendingIndexChanges.add(filePath);
+  if (reindexTimeout) clearTimeout(reindexTimeout);
+  reindexTimeout = setTimeout(async () => {
+    const count = pendingIndexChanges.size;
+    pendingIndexChanges.clear();
+    logInfo(`${pc.dim(`[index] ${count} file(s) changed, updating index...`)}`);
+    await buildDuplicatesIndex(appRoot);
+  }, 2e3);
+}
+var isPreparingCoverage = false;
+function isCoverageRuleEnabled(appRoot) {
+  const eslintConfigPath = findEslintConfigFile(appRoot);
+  if (!eslintConfigPath) return false;
+  const ruleConfigs = readRuleConfigsFromConfig(eslintConfigPath);
+  const coverageConfig = ruleConfigs.get("require-test-coverage");
+  if (!coverageConfig) return false;
+  return coverageConfig.severity !== "off";
+}
+async function buildCoverageData(appRoot) {
+  if (isPreparingCoverage) return;
+  isPreparingCoverage = true;
+  try {
+    if (!isCoverageRuleEnabled(appRoot)) {
+      logInfo(`${pc.dim("Coverage rule not enabled, skipping preparation")}`);
+      return;
+    }
+    const setup = detectCoverageSetup(appRoot);
+    if (!needsCoveragePreparation(setup)) {
+      logInfo(`${pc.dim("Coverage data is up-to-date")}`);
+      return;
+    }
+    logInfo(`${pc.blue("Preparing coverage data...")}`);
+    broadcast({ type: "coverage:setup:start" });
+    const skipPackageInstall = process.env.UILINT_SKIP_COVERAGE_INSTALL === "1";
+    const skipTests = process.env.UILINT_SKIP_COVERAGE_TESTS === "1";
+    const result = await prepareCoverage({
+      appRoot,
+      skipPackageInstall,
+      skipTests,
+      onProgress: (message, phase) => {
+        logInfo(`  ${message}`);
+        broadcast({ type: "coverage:setup:progress", message, phase });
+      }
+    });
+    if (result.error) {
+      logWarning(`Coverage preparation completed with errors: ${result.error}`);
+    } else {
+      const parts = [];
+      if (result.packageAdded) parts.push("package installed");
+      if (result.configModified) parts.push("config modified");
+      if (result.testsRan) parts.push("tests ran");
+      if (result.coverageGenerated) parts.push("coverage generated");
+      logSuccess(
+        `${pc.green("Coverage prepared:")} ${parts.join(", ")} in ${(result.duration / 1e3).toFixed(1)}s`
+      );
+    }
+    broadcast({
+      type: "coverage:setup:complete",
+      ...result
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logError(`Coverage preparation failed: ${msg}`);
+    broadcast({ type: "coverage:setup:error", error: msg });
+  } finally {
+    isPreparingCoverage = false;
+  }
+}
 function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
   logInfo(
     `${pc.dim("[ws]")} rule:config:set ${pc.bold(ruleId)} -> ${pc.dim(severity)}${options ? ` with options` : ""}`
@@ -2279,9 +2453,26 @@ async function serve(options) {
     ignoreInitial: true
   });
   fileWatcher.on("change", (path) => {
-    handleFileChange(resolve5(path));
+    const resolvedPath = resolve5(path);
+    if (resolvedPath.endsWith("coverage-final.json")) {
+      handleCoverageFileChange(resolvedPath);
+      return;
+    }
+    handleFileChange(resolvedPath);
+    scheduleReindex(appRoot, resolvedPath);
   });
+  const coveragePath = join3(appRoot, "coverage", "coverage-final.json");
+  if (existsSync5(coveragePath)) {
+    fileWatcher.add(coveragePath);
+    logInfo(`Watching coverage: ${pc.dim(coveragePath)}`);
+  }
   const wss = new WebSocketServer({ port });
+  buildDuplicatesIndex(appRoot).catch((err) => {
+    logError(`Failed to build duplicates index: ${err.message}`);
+  });
+  buildCoverageData(appRoot).catch((err) => {
+    logWarning(`Failed to prepare coverage: ${err.message}`);
+  });
   wss.on("connection", (ws) => {
     connectedClients += 1;
     connectedClientsSet.add(ws);
@@ -2296,7 +2487,7 @@ async function serve(options) {
     const currentRuleConfigs = eslintConfigPath ? readRuleConfigsFromConfig(eslintConfigPath) : /* @__PURE__ */ new Map();
     sendMessage(ws, {
       type: "rules:metadata",
-      rules: ruleRegistry.map((rule) => {
+      rules: ruleRegistry.filter((rule) => currentRuleConfigs.has(rule.id)).map((rule) => {
         const currentConfig = currentRuleConfigs.get(rule.id);
         return {
           id: rule.id,
@@ -2335,12 +2526,12 @@ async function serve(options) {
     `UILint WebSocket server running on ${pc.cyan(`ws://localhost:${port}`)}`
   );
   logInfo("Press Ctrl+C to stop");
-  await new Promise((resolve7) => {
+  await new Promise((resolve8) => {
     process.on("SIGINT", () => {
       logInfo("Shutting down...");
       wss.close();
       fileWatcher?.close();
-      resolve7();
+      resolve8();
     });
   });
 }
@@ -2884,7 +3075,7 @@ function parseOptionsJson(optionsStr) {
   }
 }
 async function sendConfigMessage(port, key, value) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const url = `ws://localhost:${port}`;
     const ws = new WebSocket2(url);
     let resolved = false;
@@ -2892,7 +3083,7 @@ async function sendConfigMessage(port, key, value) {
       if (!resolved) {
         resolved = true;
         ws.close();
-        resolve7(false);
+        resolve8(false);
       }
     }, 5e3);
     ws.on("open", () => {
@@ -2903,7 +3094,7 @@ async function sendConfigMessage(port, key, value) {
           resolved = true;
           clearTimeout(timeout);
           ws.close();
-          resolve7(true);
+          resolve8(true);
         }
       }, 100);
     });
@@ -2911,13 +3102,13 @@ async function sendConfigMessage(port, key, value) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        resolve7(false);
+        resolve8(false);
       }
     });
   });
 }
 async function sendRuleConfigMessage(port, ruleId, severity, options) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const url = `ws://localhost:${port}`;
     const ws = new WebSocket2(url);
     let resolved = false;
@@ -2926,7 +3117,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
       if (!resolved) {
         resolved = true;
         ws.close();
-        resolve7({ success: false, error: "Request timed out" });
+        resolve8({ success: false, error: "Request timed out" });
       }
     }, 1e4);
     ws.on("open", () => {
@@ -2947,7 +3138,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
             resolved = true;
             clearTimeout(timeout);
             ws.close();
-            resolve7({
+            resolve8({
               success: msg.success,
               error: msg.error
             });
@@ -2960,7 +3151,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        resolve7({ success: false, error: "Connection error" });
+        resolve8({ success: false, error: "Connection error" });
       }
     });
   });
@@ -3086,6 +3277,275 @@ async function config2(action, key, value, extraArg, options = {}) {
   }
 }
 
+// src/commands/duplicates/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/duplicates/index-cmd.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+function indexCommand() {
+  return new Command("index").description("Build or update the semantic duplicates index").option("--force", "Rebuild index from scratch").option("--model <name>", "Embedding model (default: nomic-embed-text)").option(
+    "--exclude <glob>",
+    "Exclude patterns (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).option("-o, --output <format>", "Output format: text or json", "text").action(async (options) => {
+    const { indexDirectory } = await import("uilint-duplicates");
+    const projectRoot = process.cwd();
+    const isJson = options.output === "json";
+    let spinner;
+    if (!isJson) {
+      spinner = ora("Initializing indexer...").start();
+    }
+    try {
+      const result = await indexDirectory(projectRoot, {
+        force: options.force,
+        model: options.model,
+        exclude: options.exclude,
+        onProgress: (message, current, total) => {
+          if (spinner) {
+            if (current && total) {
+              spinner.text = `${message} (${current}/${total})`;
+            } else {
+              spinner.text = message;
+            }
+          }
+        }
+      });
+      if (isJson) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        spinner?.succeed(chalk2.green("Index complete"));
+        console.log();
+        console.log(chalk2.bold("Index Statistics:"));
+        console.log(`  Files added:    ${result.added}`);
+        console.log(`  Files modified: ${result.modified}`);
+        console.log(`  Files deleted:  ${result.deleted}`);
+        console.log(`  Total chunks:   ${result.totalChunks}`);
+        console.log(`  Duration:       ${(result.duration / 1e3).toFixed(2)}s`);
+      }
+    } catch (error) {
+      if (spinner) {
+        spinner.fail(chalk2.red("Index failed"));
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk2.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/duplicates/find.ts
+import { Command as Command2 } from "commander";
+import { relative as relative2 } from "path";
+import chalk3 from "chalk";
+function findCommand() {
+  return new Command2("find").description("Find semantic duplicate groups in the codebase").option(
+    "--threshold <n>",
+    "Similarity threshold 0-1 (default: 0.85)",
+    parseFloat
+  ).option("--min-size <n>", "Minimum group size (default: 2)", parseInt).option("--kind <type>", "Filter: component, hook, function").option("-o, --output <format>", "Output format: text or json", "text").action(async (options) => {
+    const { findDuplicates } = await import("uilint-duplicates");
+    const projectRoot = process.cwd();
+    const isJson = options.output === "json";
+    try {
+      const groups = await findDuplicates({
+        path: projectRoot,
+        threshold: options.threshold,
+        minGroupSize: options.minSize,
+        kind: options.kind
+      });
+      if (isJson) {
+        console.log(JSON.stringify({ groups }, null, 2));
+        return;
+      }
+      if (groups.length === 0) {
+        console.log(chalk3.green("No semantic duplicates found."));
+        return;
+      }
+      console.log(
+        chalk3.bold(
+          `Found ${groups.length} duplicate group${groups.length > 1 ? "s" : ""}:
+`
+        )
+      );
+      groups.forEach((group, idx) => {
+        const similarity = Math.round(group.avgSimilarity * 100);
+        console.log(
+          chalk3.yellow(
+            `Duplicate Group ${idx + 1} (${similarity}% similar, ${group.members.length} occurrences):`
+          )
+        );
+        group.members.forEach((member) => {
+          const relPath = relative2(projectRoot, member.filePath);
+          const location = `${relPath}:${member.startLine}-${member.endLine}`;
+          const name = member.name || "(anonymous)";
+          const score = member.score === 1 ? "" : chalk3.dim(` (${Math.round(member.score * 100)}%)`);
+          console.log(`  ${chalk3.cyan(location.padEnd(50))} ${name}${score}`);
+        });
+        console.log(
+          chalk3.dim(
+            `  Suggestion: Consider extracting shared logic into a reusable ${group.kind}
+`
+          )
+        );
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk3.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/duplicates/search.ts
+import { Command as Command3 } from "commander";
+import { relative as relative3 } from "path";
+import chalk4 from "chalk";
+function searchCommand() {
+  return new Command3("search").description("Semantic search for similar code").argument("<query>", "Search query (natural language)").option("-k, --top <n>", "Number of results (default: 10)", parseInt).option("--threshold <n>", "Minimum similarity (default: 0.5)", parseFloat).option("-o, --output <format>", "Output format: text or json", "text").action(async (query, options) => {
+    const { searchSimilar } = await import("uilint-duplicates");
+    const projectRoot = process.cwd();
+    const isJson = options.output === "json";
+    try {
+      const results = await searchSimilar(query, {
+        path: projectRoot,
+        top: options.top,
+        threshold: options.threshold
+      });
+      if (isJson) {
+        console.log(JSON.stringify({ results }, null, 2));
+        return;
+      }
+      if (results.length === 0) {
+        console.log(chalk4.yellow("No matching code found."));
+        return;
+      }
+      console.log(chalk4.bold(`Found ${results.length} matching results:
+`));
+      results.forEach((result, idx) => {
+        const relPath = relative3(projectRoot, result.filePath);
+        const location = `${relPath}:${result.startLine}-${result.endLine}`;
+        const name = result.name || "(anonymous)";
+        const score = Math.round(result.score * 100);
+        const kindLabel = result.kind.padEnd(10);
+        console.log(
+          `${chalk4.dim(`${idx + 1}.`)} ${chalk4.cyan(location)}`
+        );
+        console.log(
+          `   ${chalk4.dim(kindLabel)} ${chalk4.bold(name)} ${chalk4.green(`(${score}% similar)`)}`
+        );
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk4.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/duplicates/similar.ts
+import { Command as Command4 } from "commander";
+import { relative as relative4, resolve as resolve7, isAbsolute as isAbsolute2 } from "path";
+import chalk5 from "chalk";
+function similarCommand() {
+  return new Command4("similar").description("Find code similar to a specific location").argument("<location>", "File location in format file:line (e.g., src/Button.tsx:15)").option("-k, --top <n>", "Number of results (default: 10)", parseInt).option("--threshold <n>", "Minimum similarity (default: 0.7)", parseFloat).option("-o, --output <format>", "Output format: text or json", "text").action(async (location, options) => {
+    const { findSimilarAtLocation } = await import("uilint-duplicates");
+    const projectRoot = process.cwd();
+    const isJson = options.output === "json";
+    const colonIdx = location.lastIndexOf(":");
+    if (colonIdx === -1) {
+      const message = "Invalid location format. Use file:line (e.g., src/Button.tsx:15)";
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk5.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+    const filePart = location.slice(0, colonIdx);
+    const linePart = location.slice(colonIdx + 1);
+    const line = parseInt(linePart, 10);
+    if (isNaN(line)) {
+      const message = `Invalid line number: ${linePart}`;
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk5.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+    const filePath = isAbsolute2(filePart) ? filePart : resolve7(projectRoot, filePart);
+    try {
+      const results = await findSimilarAtLocation({
+        path: projectRoot,
+        filePath,
+        line,
+        top: options.top,
+        threshold: options.threshold ?? 0.7
+      });
+      if (isJson) {
+        console.log(JSON.stringify({ results }, null, 2));
+        return;
+      }
+      if (results.length === 0) {
+        console.log(chalk5.yellow("No similar code found."));
+        return;
+      }
+      console.log(
+        chalk5.bold(
+          `Found ${results.length} similar code locations to ${relative4(projectRoot, filePath)}:${line}:
+`
+        )
+      );
+      results.forEach((result, idx) => {
+        const relPath = relative4(projectRoot, result.filePath);
+        const locationStr = `${relPath}:${result.startLine}-${result.endLine}`;
+        const name = result.name || "(anonymous)";
+        const score = Math.round(result.score * 100);
+        const kindLabel = result.kind.padEnd(10);
+        console.log(
+          `${chalk5.dim(`${idx + 1}.`)} ${chalk5.cyan(locationStr)}`
+        );
+        console.log(
+          `   ${chalk5.dim(kindLabel)} ${chalk5.bold(name)} ${chalk5.green(`(${score}% similar)`)}`
+        );
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (isJson) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(chalk5.red(`Error: ${message}`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/duplicates/index.ts
+function createDuplicatesCommand() {
+  const duplicates = new Command5("duplicates").description("Semantic code duplicate detection");
+  duplicates.addCommand(indexCommand());
+  duplicates.addCommand(findCommand());
+  duplicates.addCommand(searchCommand());
+  duplicates.addCommand(similarCommand());
+  return duplicates;
+}
+
 // src/index.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname7, join as join5 } from "path";
@@ -3102,7 +3562,7 @@ function assertNodeVersion(minMajor) {
   }
 }
 assertNodeVersion(20);
-var program = new Command();
+var program = new Command6();
 function getCLIVersion() {
   try {
     const __dirname = dirname7(fileURLToPath(import.meta.url));
@@ -3181,7 +3641,7 @@ program.command("update").description("Update existing style guide with new styl
   });
 });
 program.command("install").description("Install UILint integration").option("--force", "Overwrite existing configuration files").action(async (options) => {
-  const { installUI } = await import("./install-ui-TXV7A34M.js");
+  const { installUI } = await import("./install-ui-CCZ3XJDE.js");
   await installUI({ force: options.force });
 });
 program.command("serve").description("Start WebSocket server for real-time UI linting").option("-p, --port <number>", "Port to listen on", "9234").action(async (options) => {
@@ -3228,5 +3688,6 @@ program.command("config").description("Get or set UILint configuration options")
     port: parseInt(options.port, 10)
   });
 });
+program.addCommand(createDuplicatesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map