uilint 0.2.65 → 0.2.67

package/dist/index.js

@@ -25,7 +25,7 @@ import {
 import "./chunk-JPE27ROY.js";
 
 // src/index.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/commands/scan.ts
 import { dirname, resolve as resolve2 } from "path";
@@ -3720,9 +3720,728 @@ function createDuplicatesCommand() {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname7, join as join5 } from "path";
 import { fileURLToPath } from "url";
+
+// src/commands/socket/index.ts
+import { Command as Command6 } from "commander";
+import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
+import chalk6 from "chalk";
+
+// src/commands/socket/client.ts
+import WebSocket3 from "ws";
+var SocketClient = class {
+  ws = null;
+  url;
+  debug;
+  connectTimeout;
+  connected = false;
+  connectionPromise = null;
+  pendingRequests = [];
+  messageQueue = [];
+  messageHandlers = [];
+  constructor(options = {}) {
+    const port = options.port || 9234;
+    this.url = options.url || `ws://localhost:${port}`;
+    this.debug = options.debug || false;
+    this.connectTimeout = options.connectTimeout || 1e4;
+  }
+  /**
+   * Connect to the socket server
+   */
+  async connect() {
+    if (this.connected) return;
+    if (this.connectionPromise) return this.connectionPromise;
+    this.connectionPromise = new Promise((resolve8, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Connection timeout to ${this.url}`));
+      }, this.connectTimeout);
+      this.ws = new WebSocket3(this.url);
+      this.ws.on("open", () => {
+        clearTimeout(timeout);
+        this.connected = true;
+        this.log("Connected to", this.url);
+        resolve8();
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.log("Received:", message.type);
+          this.handleMessage(message);
+        } catch (e) {
+          console.error("Failed to parse message:", e);
+        }
+      });
+      this.ws.on("error", (err) => {
+        clearTimeout(timeout);
+        if (!this.connected) {
+          reject(err);
+        } else {
+          console.error("WebSocket error:", err);
+        }
+      });
+      this.ws.on("close", () => {
+        this.connected = false;
+        this.log("Disconnected");
+        for (const req of this.pendingRequests) {
+          clearTimeout(req.timeout);
+          req.reject(new Error("Disconnected"));
+        }
+        this.pendingRequests = [];
+      });
+    });
+    return this.connectionPromise;
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+      this.connected = false;
+      this.connectionPromise = null;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Add a handler for all incoming messages
+   */
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+    return () => {
+      this.messageHandlers = this.messageHandlers.filter((h) => h !== handler);
+    };
+  }
+  /**
+   * Send a raw message
+   */
+  send(message) {
+    if (!this.ws || !this.connected) {
+      throw new Error("Not connected");
+    }
+    this.log("Sending:", message.type);
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Wait for a message matching the predicate
+   */
+  waitFor(predicate, timeout = 3e4) {
+    const existing = this.messageQueue.find(predicate);
+    if (existing) {
+      this.messageQueue = this.messageQueue.filter((m) => m !== existing);
+      return Promise.resolve(existing);
+    }
+    return new Promise((resolve8, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests = this.pendingRequests.filter(
+          (r) => r.timeout !== timeoutId
+        );
+        reject(new Error(`Timeout waiting for message (${timeout}ms)`));
+      }, timeout);
+      this.pendingRequests.push({
+        predicate,
+        resolve: resolve8,
+        reject,
+        timeout: timeoutId
+      });
+    });
+  }
+  /**
+   * Generate a unique request ID
+   */
+  generateRequestId() {
+    return `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  // ==========================================================================
+  // High-Level API Methods
+  // ==========================================================================
+  /**
+   * Wait for workspace info (sent on connect)
+   */
+  async waitForWorkspaceInfo(timeout = 5e3) {
+    const existing = this.messageQueue.find((m) => m.type === "workspace:info");
+    if (existing) {
+      return existing;
+    }
+    return await this.waitFor(
+      (msg) => msg.type === "workspace:info",
+      timeout
+    );
+  }
+  /**
+   * Wait for rules metadata (sent on connect)
+   */
+  async waitForRulesMetadata(timeout = 5e3) {
+    const existing = this.messageQueue.find((m) => m.type === "rules:metadata");
+    if (existing) {
+      return existing;
+    }
+    return await this.waitFor(
+      (msg) => msg.type === "rules:metadata",
+      timeout
+    );
+  }
+  /**
+   * Lint a file
+   */
+  async lintFile(filePath, timeout = 3e4) {
+    const requestId = this.generateRequestId();
+    this.send({ type: "lint:file", filePath, requestId });
+    return await this.waitFor(
+      (msg) => msg.type === "lint:result" && msg.requestId === requestId,
+      timeout
+    );
+  }
+  /**
+   * Lint a specific element
+   */
+  async lintElement(filePath, dataLoc, timeout = 3e4) {
+    const requestId = this.generateRequestId();
+    this.send({ type: "lint:element", filePath, dataLoc, requestId });
+    return await this.waitFor(
+      (msg) => msg.type === "lint:result" && msg.requestId === requestId,
+      timeout
+    );
+  }
+  /**
+   * Check if vision analysis is available
+   */
+  async visionCheck(timeout = 1e4) {
+    const requestId = this.generateRequestId();
+    this.send({ type: "vision:check", requestId });
+    return await this.waitFor(
+      (msg) => msg.type === "vision:status" && msg.requestId === requestId,
+      timeout
+    );
+  }
+  /**
+   * Run vision analysis
+   */
+  async visionAnalyze(params, timeout = 12e4) {
+    const requestId = this.generateRequestId();
+    this.send({
+      type: "vision:analyze",
+      route: params.route,
+      timestamp: Date.now(),
+      screenshot: params.screenshot,
+      screenshotFile: params.screenshotFile,
+      manifest: params.manifest,
+      requestId
+    });
+    return await this.waitFor(
+      (msg) => msg.type === "vision:result" && msg.requestId === requestId,
+      timeout
+    );
+  }
+  /**
+   * Fetch source code
+   */
+  async fetchSource(filePath, timeout = 1e4) {
+    const requestId = this.generateRequestId();
+    this.send({ type: "source:fetch", filePath, requestId });
+    return await this.waitFor(
+      (msg) => (msg.type === "source:result" || msg.type === "source:error") && (msg.requestId === requestId || msg.requestId === requestId),
+      timeout
+    );
+  }
+  /**
+   * Request coverage data
+   */
+  async requestCoverage(timeout = 3e4) {
+    const requestId = this.generateRequestId();
+    this.send({ type: "coverage:request", requestId });
+    return await this.waitFor(
+      (msg) => (msg.type === "coverage:result" || msg.type === "coverage:error") && (msg.requestId === requestId || msg.requestId === requestId),
+      timeout
+    );
+  }
+  /**
+   * Set rule configuration
+   */
+  async setRuleConfig(ruleId, severity, options, timeout = 1e4) {
+    const requestId = this.generateRequestId();
+    this.send({
+      type: "rule:config:set",
+      ruleId,
+      severity,
+      options,
+      requestId
+    });
+    return await this.waitFor(
+      (msg) => msg.type === "rule:config:result" && msg.requestId === requestId,
+      timeout
+    );
+  }
+  /**
+   * Set a configuration value
+   */
+  setConfig(key, value) {
+    this.send({ type: "config:set", key, value });
+  }
+  /**
+   * Subscribe to file changes
+   */
+  subscribeFile(filePath) {
+    this.send({ type: "subscribe:file", filePath });
+  }
+  /**
+   * Invalidate cache
+   */
+  invalidateCache(filePath) {
+    this.send({ type: "cache:invalidate", filePath });
+  }
+  /**
+   * Get all queued messages
+   */
+  getMessages() {
+    return [...this.messageQueue];
+  }
+  /**
+   * Clear message queue
+   */
+  clearMessages() {
+    this.messageQueue = [];
+  }
+  handleMessage(message) {
+    for (const handler of this.messageHandlers) {
+      handler(message);
+    }
+    for (let i = 0; i < this.pendingRequests.length; i++) {
+      const req = this.pendingRequests[i];
+      if (req.predicate(message)) {
+        clearTimeout(req.timeout);
+        this.pendingRequests.splice(i, 1);
+        req.resolve(message);
+        return;
+      }
+    }
+    this.messageQueue.push(message);
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[SocketClient]", ...args);
+    }
+  }
+};
+async function createSocketClient(options = {}) {
+  const client = new SocketClient(options);
+  await client.connect();
+  return client;
+}
+
+// src/commands/socket/index.ts
+function formatMessage(msg, json) {
+  if (json) {
+    return JSON.stringify(msg, null, 2);
+  }
+  switch (msg.type) {
+    case "lint:result": {
+      const lines = [`${chalk6.cyan("lint:result")} ${msg.filePath}`];
+      if (msg.issues.length === 0) {
+        lines.push(chalk6.green("  No issues found"));
+      } else {
+        for (const issue of msg.issues) {
+          const loc = issue.column ? `${issue.line}:${issue.column}` : `${issue.line}`;
+          const rule = issue.ruleId ? chalk6.dim(` [${issue.ruleId}]`) : "";
+          lines.push(`  ${chalk6.yellow(loc)} ${issue.message}${rule}`);
+        }
+      }
+      return lines.join("\n");
+    }
+    case "vision:status":
+      if (msg.available) {
+        return `${chalk6.cyan("vision:status")} ${chalk6.green("available")} (${msg.model})`;
+      }
+      return `${chalk6.cyan("vision:status")} ${chalk6.red("not available")}`;
+    case "vision:result": {
+      const lines = [
+        `${chalk6.cyan("vision:result")} ${msg.route} (${msg.analysisTime}ms)`
+      ];
+      if (msg.error) {
+        lines.push(chalk6.red(`  Error: ${msg.error}`));
+      } else if (msg.issues.length === 0) {
+        lines.push(chalk6.green("  No issues found"));
+      } else {
+        for (const issue of msg.issues) {
+          const severity = issue.severity === "error" ? chalk6.red("error") : issue.severity === "warning" ? chalk6.yellow("warn") : chalk6.blue("info");
+          lines.push(`  ${severity} [${issue.category}] ${issue.message}`);
+          if (issue.dataLoc) {
+            lines.push(chalk6.dim(`    at ${issue.dataLoc}`));
+          }
+        }
+      }
+      return lines.join("\n");
+    }
+    case "workspace:info":
+      return `${chalk6.cyan("workspace:info")}
+  appRoot: ${msg.appRoot}
+  workspaceRoot: ${msg.workspaceRoot}`;
+    case "rules:metadata":
+      return `${chalk6.cyan("rules:metadata")} ${msg.rules.length} rules available`;
+    case "source:result":
+      return `${chalk6.cyan("source:result")} ${msg.filePath} (${msg.totalLines} lines)`;
+    case "source:error":
+      return `${chalk6.cyan("source:error")} ${msg.filePath}: ${chalk6.red(msg.error)}`;
+    case "coverage:result":
+      return `${chalk6.cyan("coverage:result")} Coverage data received`;
+    case "coverage:error":
+      return `${chalk6.cyan("coverage:error")} ${chalk6.red(msg.error)}`;
+    case "rule:config:result":
+      if (msg.success) {
+        return `${chalk6.cyan("rule:config:result")} ${msg.ruleId} -> ${msg.severity}`;
+      }
+      return `${chalk6.cyan("rule:config:result")} ${msg.ruleId} ${chalk6.red("failed")}: ${msg.error}`;
+    case "duplicates:indexing:start":
+      return `${chalk6.cyan("duplicates:indexing:start")}`;
+    case "duplicates:indexing:progress":
+      return `${chalk6.cyan("duplicates:indexing:progress")} ${msg.message}`;
+    case "duplicates:indexing:complete":
+      return `${chalk6.cyan("duplicates:indexing:complete")} ${msg.totalChunks} chunks in ${msg.duration}ms`;
+    case "duplicates:indexing:error":
+      return `${chalk6.cyan("duplicates:indexing:error")} ${chalk6.red(msg.error)}`;
+    case "file:changed":
+      return `${chalk6.cyan("file:changed")} ${msg.filePath}`;
+    case "config:update":
+      return `${chalk6.cyan("config:update")} ${msg.key} = ${JSON.stringify(msg.value)}`;
+    default:
+      return `${chalk6.cyan(msg.type)} ${JSON.stringify(msg)}`;
+  }
+}
+async function runRepl(client, options) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk6.green("uilint> ")
+  });
+  console.log(chalk6.bold("\nUILint Socket REPL"));
+  console.log("Type 'help' for available commands, 'exit' to quit.\n");
+  client.onMessage((msg) => {
+    console.log("\n" + formatMessage(msg, options.json));
+    rl.prompt();
+  });
+  try {
+    await client.waitForWorkspaceInfo(2e3);
+  } catch {
+  }
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    const [cmd, ...args] = trimmed.split(/\s+/);
+    try {
+      switch (cmd) {
+        case "help":
+          console.log(`
+Available commands:
+  lint:file <path>              Lint a file
+  lint:element <path> <dataLoc> Lint a specific element
+  vision:check                  Check if vision is available
+  vision:analyze <route> <manifestFile> [screenshotFile]
+                                Run vision analysis
+  source:fetch <path>           Fetch source code
+  coverage:request              Request coverage data
+  rule:config <ruleId> <severity> [optionsJson]
+                                Set rule configuration
+  config:set <key> <value>      Set a config value
+  subscribe <path>              Subscribe to file changes
+  invalidate [path]             Invalidate cache
+  messages                      Show queued messages
+  clear                         Clear message queue
+  json                          Toggle JSON output
+  exit                          Exit REPL
+`);
+          break;
+        case "lint:file":
+          if (!args[0]) {
+            console.log(chalk6.red("Usage: lint:file <path>"));
+          } else {
+            const result = await client.lintFile(args[0], options.timeout);
+            console.log(formatMessage(result, options.json));
+          }
+          break;
+        case "lint:element":
+          if (!args[0] || !args[1]) {
+            console.log(chalk6.red("Usage: lint:element <path> <dataLoc>"));
+          } else {
+            const result = await client.lintElement(args[0], args[1], options.timeout);
+            console.log(formatMessage(result, options.json));
+          }
+          break;
+        case "vision:check": {
+          const result = await client.visionCheck(options.timeout);
+          console.log(formatMessage(result, options.json));
+          break;
+        }
+        case "vision:analyze":
+          if (!args[0] || !args[1]) {
+            console.log(chalk6.red("Usage: vision:analyze <route> <manifestFile> [screenshotFile]"));
+          } else {
+            const manifestPath = args[1];
+            if (!existsSync7(manifestPath)) {
+              console.log(chalk6.red(`Manifest file not found: ${manifestPath}`));
+            } else {
+              const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+              const params = { route: args[0], manifest };
+              if (args[2]) {
+                if (existsSync7(args[2])) {
+                  const imageBuffer = readFileSync3(args[2]);
+                  params.screenshot = imageBuffer.toString("base64");
+                } else {
+                  console.log(chalk6.red(`Screenshot file not found: ${args[2]}`));
+                  break;
+                }
+              }
+              const result = await client.visionAnalyze(params, options.timeout);
+              console.log(formatMessage(result, options.json));
+            }
+          }
+          break;
+        case "source:fetch":
+          if (!args[0]) {
+            console.log(chalk6.red("Usage: source:fetch <path>"));
+          } else {
+            const result = await client.fetchSource(args[0], options.timeout);
+            console.log(formatMessage(result, options.json));
+          }
+          break;
+        case "coverage:request": {
+          const result = await client.requestCoverage(options.timeout);
+          console.log(formatMessage(result, options.json));
+          break;
+        }
+        case "rule:config":
+          if (!args[0] || !args[1]) {
+            console.log(chalk6.red("Usage: rule:config <ruleId> <severity> [optionsJson]"));
+          } else {
+            const severity = args[1];
+            const ruleOptions = args[2] ? JSON.parse(args[2]) : void 0;
+            const result = await client.setRuleConfig(args[0], severity, ruleOptions, options.timeout);
+            console.log(formatMessage(result, options.json));
+          }
+          break;
+        case "config:set":
+          if (!args[0] || !args[1]) {
+            console.log(chalk6.red("Usage: config:set <key> <value>"));
+          } else {
+            let value = args[1];
+            try {
+              value = JSON.parse(args[1]);
+            } catch {
+            }
+            client.setConfig(args[0], value);
+            console.log(chalk6.green(`Set ${args[0]} = ${JSON.stringify(value)}`));
+          }
+          break;
+        case "subscribe":
+          if (!args[0]) {
+            console.log(chalk6.red("Usage: subscribe <path>"));
+          } else {
+            client.subscribeFile(args[0]);
+            console.log(chalk6.green(`Subscribed to ${args[0]}`));
+          }
+          break;
+        case "invalidate":
+          client.invalidateCache(args[0]);
+          console.log(chalk6.green(args[0] ? `Invalidated ${args[0]}` : "Invalidated all cache"));
+          break;
+        case "messages": {
+          const msgs = client.getMessages();
+          if (msgs.length === 0) {
+            console.log(chalk6.dim("No queued messages"));
+          } else {
+            for (const msg of msgs) {
+              console.log(formatMessage(msg, options.json));
+            }
+          }
+          break;
+        }
+        case "clear":
+          client.clearMessages();
+          console.log(chalk6.green("Message queue cleared"));
+          break;
+        case "json":
+          options.json = !options.json;
+          console.log(chalk6.green(`JSON output ${options.json ? "enabled" : "disabled"}`));
+          break;
+        case "exit":
+        case "quit":
+          client.disconnect();
+          rl.close();
+          process.exit(0);
+          break;
+        default:
+          console.log(chalk6.red(`Unknown command: ${cmd}. Type 'help' for available commands.`));
+      }
+    } catch (err) {
+      console.log(chalk6.red(`Error: ${err.message}`));
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    client.disconnect();
+    process.exit(0);
+  });
+}
+async function runListen(client, options, filter) {
+  console.log(chalk6.bold("\nListening for messages..."));
+  if (filter) {
+    console.log(chalk6.dim(`Filter: ${filter}`));
+  }
+  console.log(chalk6.dim("Press Ctrl+C to stop.\n"));
+  client.onMessage((msg) => {
+    if (filter && !msg.type.includes(filter.replace("*", ""))) {
+      return;
+    }
+    console.log(formatMessage(msg, options.json));
+  });
+  await new Promise(() => {
+  });
+}
+function createSocketCommand() {
+  const cmd = new Command6("socket").description("Interact with the UILint socket server").option("-p, --port <number>", "Socket server port", "9234").option("-d, --debug", "Enable debug logging", false).option("-j, --json", "Output JSON format", false).option("-t, --timeout <ms>", "Request timeout in milliseconds", "30000");
+  cmd.action(async (cmdOptions) => {
+    const options = {
+      port: parseInt(cmdOptions.port, 10),
+      debug: cmdOptions.debug,
+      json: cmdOptions.json,
+      timeout: parseInt(cmdOptions.timeout, 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      await runRepl(client, options);
+    } catch (err) {
+      console.error(chalk6.red(`Failed to connect: ${err.message}`));
+      console.error(chalk6.dim(`Make sure the server is running: uilint serve -p ${options.port}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("listen").description("Listen for all messages from the server").option("-f, --filter <pattern>", "Filter messages by type pattern (e.g., lint:*, vision:*)").action(async (subOptions, command) => {
+    const parentOptions = command.parent?.opts() || {};
+    const options = {
+      port: parseInt(parentOptions.port || "9234", 10),
+      debug: parentOptions.debug || false,
+      json: parentOptions.json || false,
+      timeout: parseInt(parentOptions.timeout || "30000", 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      await runListen(client, options, subOptions.filter);
+    } catch (err) {
+      console.error(chalk6.red(`Failed to connect: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("lint:file <path>").description("Lint a file and output results").action(async (filePath, _subOptions, command) => {
+    const parentOptions = command.parent?.opts() || {};
+    const options = {
+      port: parseInt(parentOptions.port || "9234", 10),
+      debug: parentOptions.debug || false,
+      json: parentOptions.json || false,
+      timeout: parseInt(parentOptions.timeout || "30000", 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      await client.waitForWorkspaceInfo(2e3).catch(() => {
+      });
+      const result = await client.lintFile(filePath, options.timeout);
+      console.log(formatMessage(result, options.json));
+      client.disconnect();
+      process.exit(result.issues.length > 0 ? 1 : 0);
+    } catch (err) {
+      console.error(chalk6.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("vision:check").description("Check if vision analysis is available").action(async (_subOptions, command) => {
+    const parentOptions = command.parent?.opts() || {};
+    const options = {
+      port: parseInt(parentOptions.port || "9234", 10),
+      debug: parentOptions.debug || false,
+      json: parentOptions.json || false,
+      timeout: parseInt(parentOptions.timeout || "10000", 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      const result = await client.visionCheck(options.timeout);
+      console.log(formatMessage(result, options.json));
+      client.disconnect();
+      process.exit(result.available ? 0 : 1);
+    } catch (err) {
+      console.error(chalk6.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("source:fetch <path>").description("Fetch source code for a file").action(async (filePath, _subOptions, command) => {
+    const parentOptions = command.parent?.opts() || {};
+    const options = {
+      port: parseInt(parentOptions.port || "9234", 10),
+      debug: parentOptions.debug || false,
+      json: parentOptions.json || false,
+      timeout: parseInt(parentOptions.timeout || "10000", 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      await client.waitForWorkspaceInfo(2e3).catch(() => {
+      });
+      const result = await client.fetchSource(filePath, options.timeout);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.type === "source:result") {
+        console.log(result.content);
+      } else {
+        console.error(chalk6.red(`Error: ${result.error}`));
+      }
+      client.disconnect();
+      process.exit(result.type === "source:result" ? 0 : 1);
+    } catch (err) {
+      console.error(chalk6.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  cmd.command("rules").description("List available rules").action(async (_subOptions, command) => {
+    const parentOptions = command.parent?.opts() || {};
+    const options = {
+      port: parseInt(parentOptions.port || "9234", 10),
+      debug: parentOptions.debug || false,
+      json: parentOptions.json || false,
+      timeout: parseInt(parentOptions.timeout || "10000", 10)
+    };
+    try {
+      const client = await createSocketClient({ port: options.port, debug: options.debug });
+      const metadata = await client.waitForRulesMetadata(options.timeout);
+      if (options.json) {
+        console.log(JSON.stringify(metadata.rules, null, 2));
+      } else {
+        console.log(chalk6.bold(`
+${metadata.rules.length} rules available:
+`));
+        for (const rule of metadata.rules) {
+          const severity = rule.currentSeverity === "error" ? chalk6.red("error") : rule.currentSeverity === "warn" ? chalk6.yellow("warn") : chalk6.dim("off");
+          console.log(`  ${chalk6.cyan(rule.id)} [${severity}]`);
+          console.log(chalk6.dim(`    ${rule.description}`));
+        }
+      }
+      client.disconnect();
+    } catch (err) {
+      console.error(chalk6.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/index.ts
 function assertNodeVersion(minMajor, minMinor) {
   const ver = process.versions.node || "";
   const parts = ver.split(".");
@@ -3737,12 +4456,12 @@ function assertNodeVersion(minMajor, minMinor) {
   }
 }
 assertNodeVersion(20, 19);
-var program = new Command6();
+var program = new Command7();
 function getCLIVersion() {
   try {
     const __dirname = dirname7(fileURLToPath(import.meta.url));
     const pkgPath = join5(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -3868,6 +4587,7 @@ program.command("config").description("Get or set UILint configuration options")
   });
 });
 program.addCommand(createDuplicatesCommand());
+program.addCommand(createSocketCommand());
 program.command("upgrade").description("Update installed ESLint rules to latest versions").option("--check", "Show available updates without applying").option("-y, --yes", "Auto-confirm all updates").option("--dry-run", "Show what would change without modifying files").option("--rule <id>", "Upgrade only a specific rule").action(async (options) => {
   const { upgrade } = await import("./upgrade-TGYLZ4QX.js");
   await upgrade({