uilint 0.2.22 → 0.2.26

package/dist/index.js

@@ -1,21 +1,29 @@
 #!/usr/bin/env node
 import {
   createSpinner,
+  detectCoverageSetup,
   detectNextAppRouter,
+  findEslintConfigFile,
   findNextAppRouterProjects,
   intro,
   logError,
   logInfo,
   logSuccess,
   logWarning,
+  needsCoveragePreparation,
   note,
   outro,
   pc,
+  prepareCoverage,
+  readRuleConfigsFromConfig,
+  updateRuleConfigInConfig,
+  updateRuleSeverityInConfig,
   withSpinner
-} from "./chunk-FRNXXIEM.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";
@@ -251,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(
@@ -1168,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);
     });
   });
 }
@@ -2154,6 +2162,42 @@ ${stack}` : ""
       handleConfigSet(key, value);
       break;
     }
+    case "rule:config:set": {
+      const { ruleId, severity, options, requestId } = message;
+      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) {
@@ -2179,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) {
@@ -2192,6 +2254,191 @@ function handleConfigSet(key, value) {
   logInfo(`${pc.dim("[ws]")} config:set ${pc.bold(key)} = ${pc.dim(JSON.stringify(value))}`);
   broadcastConfigUpdate(key, value);
 }
+function broadcastRuleConfigChange(ruleId, severity, options) {
+  const message = {
+    type: "rule:config:changed",
+    ruleId,
+    severity,
+    options
+  };
+  for (const ws of connectedClientsSet) {
+    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` : ""}`
+  );
+  const configPath = findEslintConfigFile(serverAppRootForVision);
+  if (!configPath) {
+    const error = `No ESLint config file found in ${serverAppRootForVision}`;
+    logError(`${pc.dim("[ws]")} ${error}`);
+    sendMessage(ws, {
+      type: "rule:config:result",
+      ruleId,
+      severity,
+      options,
+      success: false,
+      error,
+      requestId
+    });
+    return;
+  }
+  let result;
+  if (options && Object.keys(options).length > 0) {
+    result = updateRuleConfigInConfig(configPath, ruleId, severity, options);
+  } else {
+    result = updateRuleSeverityInConfig(configPath, ruleId, severity);
+  }
+  if (result.success) {
+    logSuccess(
+      `${pc.dim("[ws]")} Updated ${pc.bold(`uilint/${ruleId}`)} -> ${pc.dim(severity)}`
+    );
+    eslintInstances.clear();
+    cache.clear();
+    sendMessage(ws, {
+      type: "rule:config:result",
+      ruleId,
+      severity,
+      options,
+      success: true,
+      requestId
+    });
+    broadcastRuleConfigChange(ruleId, severity, options);
+  } else {
+    logError(`${pc.dim("[ws]")} Failed to update rule: ${result.error}`);
+    sendMessage(ws, {
+      type: "rule:config:result",
+      ruleId,
+      severity,
+      options,
+      success: false,
+      error: result.error,
+      requestId
+    });
+  }
+}
 async function serve(options) {
   const port = options.port || 9234;
   const cwd = process.cwd();
@@ -2206,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);
@@ -2219,15 +2483,25 @@ async function serve(options) {
       workspaceRoot: wsRoot,
       serverCwd: cwd
     });
+    const eslintConfigPath = findEslintConfigFile(appRoot);
+    const currentRuleConfigs = eslintConfigPath ? readRuleConfigsFromConfig(eslintConfigPath) : /* @__PURE__ */ new Map();
     sendMessage(ws, {
       type: "rules:metadata",
-      rules: ruleRegistry.map((rule) => ({
-        id: rule.id,
-        name: rule.name,
-        description: rule.description,
-        category: rule.category,
-        defaultSeverity: rule.defaultSeverity
-      }))
+      rules: ruleRegistry.filter((rule) => currentRuleConfigs.has(rule.id)).map((rule) => {
+        const currentConfig = currentRuleConfigs.get(rule.id);
+        return {
+          id: rule.id,
+          name: rule.name,
+          description: rule.description,
+          category: rule.category,
+          defaultSeverity: rule.defaultSeverity,
+          currentSeverity: currentConfig?.severity,
+          currentOptions: currentConfig?.options,
+          docs: rule.docs,
+          optionSchema: rule.optionSchema,
+          defaultOptions: rule.defaultOptions
+        };
+      })
     });
     for (const [key, value] of configStore) {
       sendMessage(ws, { type: "config:update", key, value });
@@ -2252,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();
     });
   });
 }
@@ -2776,8 +3050,32 @@ function presetToPosition(preset) {
   };
   return positions[preset] || { x: 500, y: 30 };
 }
+function parseRuleConfig(value) {
+  const match = value.match(/^([^:]+):(error|warn|off)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    ruleId: match[1],
+    severity: match[2]
+  };
+}
+function parseOptionsJson(optionsStr) {
+  if (!optionsStr) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(optionsStr);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
 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;
@@ -2785,7 +3083,7 @@ async function sendConfigMessage(port, key, value) {
       if (!resolved) {
         resolved = true;
         ws.close();
-        resolve7(false);
+        resolve8(false);
       }
     }, 5e3);
     ws.on("open", () => {
@@ -2796,7 +3094,7 @@ async function sendConfigMessage(port, key, value) {
           resolved = true;
           clearTimeout(timeout);
           ws.close();
-          resolve7(true);
+          resolve8(true);
         }
       }, 100);
     });
@@ -2804,12 +3102,61 @@ 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((resolve8) => {
+    const url = `ws://localhost:${port}`;
+    const ws = new WebSocket2(url);
+    let resolved = false;
+    const requestId = `cli-${Date.now()}`;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        ws.close();
+        resolve8({ success: false, error: "Request timed out" });
+      }
+    }, 1e4);
+    ws.on("open", () => {
+      const message = JSON.stringify({
+        type: "rule:config:set",
+        ruleId,
+        severity,
+        options,
+        requestId
+      });
+      ws.send(message);
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "rule:config:result" && msg.requestId === requestId) {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            ws.close();
+            resolve8({
+              success: msg.success,
+              error: msg.error
+            });
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", () => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve8({ success: false, error: "Connection error" });
       }
     });
   });
 }
-async function handleSet(key, value, port) {
+async function handleSet(key, value, port, extraArg) {
   switch (key) {
     case "position": {
       const parsed = parsePosition(value);
@@ -2839,6 +3186,50 @@ Expected format: x,y (e.g., 100,50) or preset (top-center, top-left, etc.)`
       } else {
         logError(
           `Failed to set position. Is the server running?
+Start it with: ${pc.bold("npx uilint serve")}`
+        );
+        process.exit(1);
+      }
+      break;
+    }
+    case "rule": {
+      const parsed = parseRuleConfig(value);
+      if (!parsed) {
+        logError(
+          `Invalid rule config: ${value}
+Expected format: <ruleId>:<severity>
+  severity: error, warn, or off
+
+Examples:
+  uilint config set rule no-arbitrary-tailwind:warn
+  uilint config set rule no-prop-drilling-depth:error '{"maxDepth":3}'`
+        );
+        process.exit(1);
+      }
+      const options = parseOptionsJson(extraArg);
+      if (extraArg && !options) {
+        logError(
+          `Invalid options JSON: ${extraArg}
+Expected a valid JSON object, e.g., '{"maxDepth": 3}'`
+        );
+        process.exit(1);
+      }
+      logInfo(
+        `Setting rule "${parsed.ruleId}" to ${parsed.severity}` + (options ? ` with options: ${JSON.stringify(options)}` : "")
+      );
+      const result = await sendRuleConfigMessage(
+        port,
+        parsed.ruleId,
+        parsed.severity,
+        options
+      );
+      if (result.success) {
+        logSuccess(
+          `Rule "${parsed.ruleId}" set to ${parsed.severity}` + (options ? ` with options` : "")
+        );
+      } else {
+        logError(
+          result.error || `Failed to set rule config. Is the server running?
 Start it with: ${pc.bold("npx uilint serve")}`
         );
         process.exit(1);
@@ -2847,7 +3238,7 @@ Start it with: ${pc.bold("npx uilint serve")}`
     }
     default:
       logError(`Unknown config key: ${key}`);
-      logInfo(`Available keys: position`);
+      logInfo(`Available keys: position, rule`);
       process.exit(1);
   }
 }
@@ -2866,7 +3257,7 @@ To view it, check your browser's dev tools:
       process.exit(1);
   }
 }
-async function config2(action, key, value, options = {}) {
+async function config2(action, key, value, extraArg, options = {}) {
   const port = options.port || 9234;
   switch (action) {
     case "set":
@@ -2874,18 +3265,287 @@ async function config2(action, key, value, options = {}) {
         logError(`Missing value for config set ${key}`);
         process.exit(1);
       }
-      await handleSet(key, value, port);
+      await handleSet(key, value, port, extraArg);
       break;
     case "get":
       await handleGet(key, port);
       break;
     default:
       logError(`Unknown action: ${action}`);
-      logInfo(`Usage: uilint config <set|get> <key> [value]`);
+      logInfo(`Usage: uilint config <set|get> <key> [value] [options]`);
       process.exit(1);
   }
 }
 
+// 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";
@@ -2902,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));
@@ -2981,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-HTVB5HDB.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) => {
@@ -3023,10 +3683,11 @@ program.command("vision").description("Analyze a screenshot with Ollama vision m
     debugDump: options.debugDump
   });
 });
-program.command("config").description("Get or set UILint configuration options").argument("<action>", "Action: set or get").argument("<key>", "Config key (e.g., position)").argument("[value]", "Value to set (for set action)").option("-p, --port <number>", "WebSocket server port", "9234").action(async (action, key, value, options) => {
-  await config2(action, key, value, {
+program.command("config").description("Get or set UILint configuration options").argument("<action>", "Action: set or get").argument("<key>", "Config key (e.g., position, rule)").argument("[value]", "Value to set (for set action)").argument("[extraArg]", "Extra argument (e.g., options JSON for rule config)").option("-p, --port <number>", "WebSocket server port", "9234").action(async (action, key, value, extraArg, options) => {
+  await config2(action, key, value, extraArg, {
     port: parseInt(options.port, 10)
   });
 });
+program.addCommand(createDuplicatesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map