uilint 0.2.72 → 0.2.73

package/dist/index.js

@@ -25,7 +25,7 @@ import {
 import "./chunk-JPE27ROY.js";
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/scan.ts
 import { dirname, resolve as resolve2 } from "path";
@@ -261,8 +261,8 @@ async function initializeLangfuseIfEnabled() {
               },
               { asType: "generation" }
             );
-            await new Promise((resolve8) => {
-              resolveTrace = resolve8;
+            await new Promise((resolve11) => {
+              resolveTrace = resolve11;
             });
             if (endData && generationRef) {
               const usageDetails = endData.usage ? Object.fromEntries(
@@ -1178,14 +1178,14 @@ import {
 } from "uilint-core";
 import { ensureOllamaReady as ensureOllamaReady3 } from "uilint-core/node";
 async function readStdin2() {
-  return new Promise((resolve8) => {
+  return new Promise((resolve11) => {
     let data = "";
     const rl = createInterface({ input: process.stdin });
     rl.on("line", (line) => {
       data += line;
     });
     rl.on("close", () => {
-      resolve8(data);
+      resolve11(data);
     });
   });
 }
@@ -2699,12 +2699,12 @@ async function serve(options) {
     `UILint WebSocket server running on ${pc.cyan(`ws://localhost:${port}`)}`
   );
   logInfo("Press Ctrl+C to stop");
-  await new Promise((resolve8) => {
+  await new Promise((resolve11) => {
     process.on("SIGINT", () => {
       logInfo("Shutting down...");
       wss.close();
       fileWatcher?.close();
-      resolve8();
+      resolve11();
     });
   });
 }
@@ -3248,7 +3248,7 @@ function parseOptionsJson(optionsStr) {
   }
 }
 async function sendConfigMessage(port, key, value) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve11) => {
     const url = `ws://localhost:${port}`;
     const ws = new WebSocket2(url);
     let resolved = false;
@@ -3256,7 +3256,7 @@ async function sendConfigMessage(port, key, value) {
       if (!resolved) {
         resolved = true;
         ws.close();
-        resolve8(false);
+        resolve11(false);
       }
     }, 5e3);
     ws.on("open", () => {
@@ -3267,7 +3267,7 @@ async function sendConfigMessage(port, key, value) {
           resolved = true;
           clearTimeout(timeout);
           ws.close();
-          resolve8(true);
+          resolve11(true);
         }
       }, 100);
     });
@@ -3275,13 +3275,13 @@ async function sendConfigMessage(port, key, value) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        resolve8(false);
+        resolve11(false);
       }
     });
   });
 }
 async function sendRuleConfigMessage(port, ruleId, severity, options) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve11) => {
     const url = `ws://localhost:${port}`;
     const ws = new WebSocket2(url);
     let resolved = false;
@@ -3290,7 +3290,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
       if (!resolved) {
         resolved = true;
         ws.close();
-        resolve8({ success: false, error: "Request timed out" });
+        resolve11({ success: false, error: "Request timed out" });
       }
     }, 1e4);
     ws.on("open", () => {
@@ -3311,7 +3311,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
             resolved = true;
             clearTimeout(timeout);
             ws.close();
-            resolve8({
+            resolve11({
               success: msg.success,
               error: msg.error
             });
@@ -3324,7 +3324,7 @@ async function sendRuleConfigMessage(port, ruleId, severity, options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        resolve8({ success: false, error: "Connection error" });
+        resolve11({ success: false, error: "Connection error" });
       }
     });
   });
@@ -3720,13 +3720,441 @@ function createDuplicatesCommand() {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname7, join as join5 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname10, join as join6 } from "path";
 import { fileURLToPath } from "url";
 
-// src/commands/socket/index.ts
+// src/commands/manifest/index.ts
 import { Command as Command6 } from "commander";
-import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname9, resolve as resolve10 } from "path";
+
+// src/commands/manifest/generator.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve9, dirname as dirname8, relative as relative6 } from "path";
+import { glob } from "glob";
+import { execSync } from "child_process";
+import { findWorkspaceRoot as findWorkspaceRoot5 } from "uilint-core/node";
+import { ruleRegistry as ruleRegistry2 } from "uilint-eslint";
+
+// src/utils/eslint-utils.ts
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname7, resolve as resolve8, relative as relative5, join as join5 } from "path";
+var ESLINT_CONFIG_FILES2 = [
+  // Flat config (ESLint v9+)
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  // Legacy config
+  ".eslintrc",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.json",
+  ".eslintrc.yaml",
+  ".eslintrc.yml"
+];
+function buildLineStarts2(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) {
+    if (code.charCodeAt(i) === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+function offsetFromLineCol2(lineStarts, line1, col0, codeLength) {
+  const lineIndex = Math.max(0, Math.min(lineStarts.length - 1, line1 - 1));
+  const base = lineStarts[lineIndex] ?? 0;
+  return Math.max(0, Math.min(codeLength, base + Math.max(0, col0)));
+}
+function buildJsxElementSpans2(code, dataLocFile) {
+  const localRequire2 = createRequire2(import.meta.url);
+  const { parse: parse3 } = localRequire2("@typescript-eslint/typescript-estree");
+  const ast = parse3(code, {
+    loc: true,
+    range: true,
+    jsx: true,
+    comment: false,
+    errorOnUnknownASTType: false
+  });
+  const spans = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "JSXElement") {
+      const range = node.range;
+      const opening = node.openingElement;
+      const loc = opening?.loc?.start;
+      if (range && typeof range[0] === "number" && typeof range[1] === "number" && loc && typeof loc.line === "number" && typeof loc.column === "number") {
+        const dataLoc = `${dataLocFile}:${loc.line}:${loc.column}`;
+        spans.push({ start: range[0], end: range[1], dataLoc });
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+  }
+  walk(ast);
+  spans.sort((a, b) => a.end - a.start - (b.end - b.start));
+  return spans;
+}
+function mapMessageToDataLoc2(params) {
+  const col0 = typeof params.messageCol1 === "number" ? Math.max(0, params.messageCol1 - 1) : 0;
+  const offset = offsetFromLineCol2(
+    params.lineStarts,
+    params.messageLine1,
+    col0,
+    params.codeLength
+  );
+  for (const s of params.spans) {
+    if (s.start <= offset && offset < s.end) return s.dataLoc;
+  }
+  return void 0;
+}
+function normalizePathSlashes2(p) {
+  return p.replace(/\\/g, "/");
+}
+function normalizeDataLocFilePath2(absoluteFilePath, projectCwd) {
+  const abs = normalizePathSlashes2(resolve8(absoluteFilePath));
+  const cwd = normalizePathSlashes2(resolve8(projectCwd));
+  if (abs === cwd || abs.startsWith(cwd + "/")) {
+    return normalizePathSlashes2(relative5(cwd, abs));
+  }
+  return abs;
+}
+function findESLintCwd2(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 30; i++) {
+    for (const cfg of ESLINT_CONFIG_FILES2) {
+      if (existsSync7(join5(dir, cfg))) return dir;
+    }
+    if (existsSync7(join5(dir, "package.json"))) return dir;
+    const parent = dirname7(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+var eslintInstances2 = /* @__PURE__ */ new Map();
+async function getESLintForProject2(projectCwd) {
+  const cached = eslintInstances2.get(projectCwd);
+  if (cached) return cached;
+  try {
+    const req = createRequire2(join5(projectCwd, "package.json"));
+    const mod = req("eslint");
+    const ESLintCtor = mod?.ESLint ?? mod?.default?.ESLint ?? mod?.default ?? mod;
+    if (!ESLintCtor) return null;
+    const eslint = new ESLintCtor({ cwd: projectCwd });
+    eslintInstances2.set(projectCwd, eslint);
+    return eslint;
+  } catch {
+    return null;
+  }
+}
+async function lintFileWithDataLoc(absolutePath, projectCwd, onProgress) {
+  const progress = onProgress ?? (() => {
+  });
+  if (!existsSync7(absolutePath)) {
+    progress(`File not found: ${absolutePath}`);
+    return [];
+  }
+  progress(`Resolving ESLint project... ${projectCwd}`);
+  const eslint = await getESLintForProject2(projectCwd);
+  if (!eslint) {
+    progress("ESLint not available");
+    return [];
+  }
+  try {
+    progress("Running ESLint...");
+    const results = await eslint.lintFiles([absolutePath]);
+    const messages = Array.isArray(results) && results.length > 0 ? results[0].messages || [] : [];
+    const dataLocFile = normalizeDataLocFilePath2(absolutePath, projectCwd);
+    let spans = [];
+    let lineStarts = [];
+    let codeLength = 0;
+    try {
+      progress("Building JSX map...");
+      const code = readFileSync3(absolutePath, "utf-8");
+      codeLength = code.length;
+      lineStarts = buildLineStarts2(code);
+      spans = buildJsxElementSpans2(code, dataLocFile);
+      progress(`JSX map: ${spans.length} element(s)`);
+    } catch (e) {
+      progress("JSX map failed (falling back to unmapped issues)");
+      spans = [];
+      lineStarts = [];
+      codeLength = 0;
+    }
+    const issues = messages.filter((m) => typeof m?.message === "string").map((m) => {
+      const line = typeof m.line === "number" ? m.line : 1;
+      const column = typeof m.column === "number" ? m.column : void 0;
+      const mappedDataLoc = spans.length > 0 && lineStarts.length > 0 && codeLength > 0 ? mapMessageToDataLoc2({
+        spans,
+        lineStarts,
+        codeLength,
+        messageLine1: line,
+        messageCol1: column
+      }) : void 0;
+      return {
+        line,
+        column,
+        message: m.message,
+        ruleId: typeof m.ruleId === "string" ? m.ruleId : void 0,
+        dataLoc: mappedDataLoc
+      };
+    });
+    const mappedCount = issues.filter((i) => Boolean(i.dataLoc)).length;
+    if (issues.length > 0) {
+      progress(`Mapped ${mappedCount}/${issues.length} issue(s) to JSX elements`);
+    }
+    return issues;
+  } catch (error) {
+    progress(`ESLint failed: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+}
+function extractSourceSnippet(code, centerLine, contextLines = 3) {
+  const allLines = code.split("\n");
+  const startLine = Math.max(1, centerLine - contextLines);
+  const endLine = Math.min(allLines.length, centerLine + contextLines);
+  return {
+    lines: allLines.slice(startLine - 1, endLine),
+    startLine,
+    endLine
+  };
+}
+
+// src/commands/manifest/generator.ts
+var DEFAULT_INCLUDE = ["**/*.tsx", "**/*.jsx"];
+var DEFAULT_EXCLUDE = [
+  "node_modules/**",
+  "dist/**",
+  ".next/**",
+  "build/**",
+  "coverage/**",
+  ".uilint/**",
+  "**/*.test.tsx",
+  "**/*.test.jsx",
+  "**/*.spec.tsx",
+  "**/*.spec.jsx"
+];
+function getGitInfo(cwd) {
+  try {
+    const commitSha = execSync("git rev-parse HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return { commitSha, branch };
+  } catch {
+    return {};
+  }
+}
+function buildRuleMetadata(appRoot) {
+  const eslintConfigPath = findEslintConfigFile(appRoot);
+  const currentRuleConfigs = eslintConfigPath ? readRuleConfigsFromConfig(eslintConfigPath) : /* @__PURE__ */ new Map();
+  return ruleRegistry2.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,
+      docs: rule.docs,
+      optionSchema: rule.optionSchema
+    };
+  });
+}
+async function generateManifest(options = {}) {
+  const cwd = resolve9(options.cwd ?? process.cwd());
+  const include = options.include ?? DEFAULT_INCLUDE;
+  const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+  const includeSnippets = options.includeSnippets ?? true;
+  const snippetContextLines = options.snippetContextLines ?? 3;
+  const onProgress = options.onProgress ?? (() => {
+  });
+  onProgress("Finding workspace root...");
+  const workspaceRoot = findWorkspaceRoot5(cwd);
+  const appRoot = cwd;
+  onProgress("Scanning for JSX/TSX files...");
+  const files = await glob(include, {
+    cwd,
+    ignore: exclude,
+    absolute: true,
+    nodir: true
+  });
+  onProgress(`Found ${files.length} files to scan`);
+  const gitInfo = getGitInfo(cwd);
+  const rules = buildRuleMetadata(appRoot);
+  onProgress(`Loaded ${rules.length} rule definitions`);
+  const manifestFiles = [];
+  let totalIssues = 0;
+  let errorCount = 0;
+  let warnCount = 0;
+  for (let i = 0; i < files.length; i++) {
+    const absolutePath = files[i];
+    const relativePath = relative6(cwd, absolutePath);
+    onProgress(`Linting ${relativePath}...`, i + 1, files.length);
+    const fileDir = dirname8(absolutePath);
+    const projectCwd = findESLintCwd2(fileDir);
+    const issues = await lintFileWithDataLoc(absolutePath, projectCwd);
+    if (issues.length === 0) continue;
+    const manifestIssues = issues.filter((issue) => Boolean(issue.dataLoc)).map((issue) => ({
+      line: issue.line,
+      column: issue.column,
+      message: issue.message,
+      ruleId: issue.ruleId,
+      dataLoc: issue.dataLoc
+    }));
+    if (manifestIssues.length === 0) continue;
+    let snippets;
+    if (includeSnippets) {
+      try {
+        const code = readFileSync4(absolutePath, "utf-8");
+        snippets = {};
+        const issuesByDataLoc = /* @__PURE__ */ new Map();
+        for (const issue of manifestIssues) {
+          if (!issuesByDataLoc.has(issue.dataLoc)) {
+            issuesByDataLoc.set(issue.dataLoc, issue);
+          }
+        }
+        for (const [dataLoc, issue] of issuesByDataLoc) {
+          snippets[dataLoc] = extractSourceSnippet(code, issue.line, snippetContextLines);
+        }
+      } catch {
+      }
+    }
+    for (const issue of manifestIssues) {
+      if (issue.ruleId) {
+        const rule = rules.find((r) => `uilint/${r.id}` === issue.ruleId || r.id === issue.ruleId);
+        const severity = rule?.currentSeverity ?? rule?.defaultSeverity ?? "warn";
+        if (severity === "error") {
+          errorCount++;
+        } else {
+          warnCount++;
+        }
+      } else {
+        warnCount++;
+      }
+    }
+    totalIssues += manifestIssues.length;
+    const dataLocFilePath = normalizeDataLocFilePath2(absolutePath, projectCwd);
+    manifestFiles.push({
+      filePath: dataLocFilePath,
+      issues: manifestIssues,
+      snippets
+    });
+  }
+  onProgress(`Scan complete: ${totalIssues} issues in ${manifestFiles.length} files`);
+  return {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceRoot,
+    appRoot,
+    commitSha: gitInfo.commitSha,
+    branch: gitInfo.branch,
+    files: manifestFiles,
+    rules,
+    summary: {
+      filesScanned: files.length,
+      filesWithIssues: manifestFiles.length,
+      totalIssues,
+      bySeverity: {
+        error: errorCount,
+        warn: warnCount
+      }
+    }
+  };
+}
+
+// src/commands/manifest/index.ts
+function createManifestCommand() {
+  const cmd = new Command6("build-manifest").description("Generate static lint manifest for production deployment").option("-o, --output <path>", "Output path for manifest", ".uilint/manifest.json").option("--include <patterns...>", "File patterns to include").option("--exclude <patterns...>", "File patterns to exclude").option("--no-snippets", "Exclude source code snippets from manifest").option("--context-lines <n>", "Number of context lines for snippets", "3").option("--pretty", "Pretty-print JSON output").option("--quiet", "Suppress progress output").action(async (options) => {
+    await buildManifest({
+      output: options.output,
+      include: options.include,
+      exclude: options.exclude,
+      includeSnippets: options.snippets !== false,
+      contextLines: parseInt(options.contextLines, 10),
+      pretty: options.pretty,
+      quiet: options.quiet
+    });
+  });
+  return cmd;
+}
+async function buildManifest(options) {
+  const startTime = Date.now();
+  const outputPath = resolve10(process.cwd(), options.output);
+  if (!options.quiet) {
+    logInfo(`Building lint manifest...`);
+    logInfo(`Output: ${pc.dim(outputPath)}`);
+  }
+  try {
+    const manifest = await generateManifest({
+      cwd: process.cwd(),
+      include: options.include,
+      exclude: options.exclude,
+      includeSnippets: options.includeSnippets,
+      snippetContextLines: options.contextLines,
+      onProgress: options.quiet ? void 0 : (message, current, total) => {
+        if (current !== void 0 && total !== void 0) {
+          logInfo(`  [${current}/${total}] ${message}`);
+        } else {
+          logInfo(`  ${message}`);
+        }
+      }
+    });
+    const outputDir = dirname9(outputPath);
+    if (!existsSync9(outputDir)) {
+      mkdirSync6(outputDir, { recursive: true });
+    }
+    const json = options.pretty ? JSON.stringify(manifest, null, 2) : JSON.stringify(manifest);
+    writeFileSync6(outputPath, json, "utf-8");
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    const sizeKb = Math.round(Buffer.byteLength(json) / 1024);
+    if (!options.quiet) {
+      logSuccess(`Manifest generated in ${elapsed}s`);
+      logInfo(`  Files scanned: ${pc.bold(String(manifest.summary.filesScanned))}`);
+      logInfo(`  Files with issues: ${pc.bold(String(manifest.summary.filesWithIssues))}`);
+      logInfo(`  Total issues: ${pc.bold(String(manifest.summary.totalIssues))}`);
+      if (manifest.summary.bySeverity.error > 0) {
+        logInfo(`    Errors: ${pc.red(String(manifest.summary.bySeverity.error))}`);
+      }
+      if (manifest.summary.bySeverity.warn > 0) {
+        logInfo(`    Warnings: ${pc.yellow(String(manifest.summary.bySeverity.warn))}`);
+      }
+      logInfo(`  Output size: ${pc.dim(`${sizeKb}kb`)}`);
+      if (manifest.commitSha) {
+        logInfo(`  Git commit: ${pc.dim(manifest.commitSha.substring(0, 7))}`);
+      }
+      if (manifest.branch) {
+        logInfo(`  Git branch: ${pc.dim(manifest.branch)}`);
+      }
+      logSuccess(`Wrote ${pc.cyan(options.output)}`);
+    }
+    if (manifest.summary.bySeverity.error > 0) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    logError(`Failed to generate manifest: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/socket/index.ts
+import { Command as Command7 } from "commander";
+import { readFileSync as readFileSync5, existsSync as existsSync10 } from "fs";
 import chalk6 from "chalk";
 
 // src/commands/socket/client.ts
@@ -3753,7 +4181,7 @@ var SocketClient = class {
   async connect() {
     if (this.connected) return;
     if (this.connectionPromise) return this.connectionPromise;
-    this.connectionPromise = new Promise((resolve8, reject) => {
+    this.connectionPromise = new Promise((resolve11, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Connection timeout to ${this.url}`));
       }, this.connectTimeout);
@@ -3762,7 +4190,7 @@ var SocketClient = class {
         clearTimeout(timeout);
         this.connected = true;
         this.log("Connected to", this.url);
-        resolve8();
+        resolve11();
       });
       this.ws.on("message", (data) => {
         try {
@@ -3838,7 +4266,7 @@ var SocketClient = class {
       this.messageQueue = this.messageQueue.filter((m) => m !== existing);
       return Promise.resolve(existing);
     }
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve11, reject) => {
       const timeoutId = setTimeout(() => {
         this.pendingRequests = this.pendingRequests.filter(
           (r) => r.timeout !== timeoutId
@@ -3847,7 +4275,7 @@ var SocketClient = class {
       }, timeout);
       this.pendingRequests.push({
         predicate,
-        resolve: resolve8,
+        resolve: resolve11,
         reject,
         timeout: timeoutId
       });
@@ -4188,14 +4616,14 @@ Available commands:
             console.log(chalk6.red("Usage: vision:analyze <route> <manifestFile> [screenshotFile]"));
           } else {
             const manifestPath = args[1];
-            if (!existsSync7(manifestPath)) {
+            if (!existsSync10(manifestPath)) {
               console.log(chalk6.red(`Manifest file not found: ${manifestPath}`));
             } else {
-              const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+              const manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
               const params = { route: args[0], manifest };
               if (args[2]) {
-                if (existsSync7(args[2])) {
-                  const imageBuffer = readFileSync3(args[2]);
+                if (existsSync10(args[2])) {
+                  const imageBuffer = readFileSync5(args[2]);
                   params.screenshot = imageBuffer.toString("base64");
                 } else {
                   console.log(chalk6.red(`Screenshot file not found: ${args[2]}`));
@@ -4309,7 +4737,7 @@ async function runListen(client, options, filter) {
   });
 }
 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");
+  const cmd = new Command7("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),
@@ -4456,12 +4884,12 @@ function assertNodeVersion(minMajor, minMinor) {
   }
 }
 assertNodeVersion(20, 19);
-var program = new Command7();
+var program = new Command8();
 function getCLIVersion() {
   try {
-    const __dirname = dirname7(fileURLToPath(import.meta.url));
-    const pkgPath = join5(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const __dirname = dirname10(fileURLToPath(import.meta.url));
+    const pkgPath = join6(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -4593,6 +5021,7 @@ program.command("config").description("Get or set UILint configuration options")
   });
 });
 program.addCommand(createDuplicatesCommand());
+program.addCommand(createManifestCommand());
 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-GUYNMGSY.js");