uilint 0.2.122 → 0.2.124

package/dist/index.js

@@ -1407,9 +1407,9 @@ async function update(options) {
 }
 
 // src/commands/serve.ts
-import { existsSync as existsSync5, statSync as statSync3, readdirSync, readFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname5, resolve as resolve5, relative, join as join3, parse as parse2 } from "path";
+import { existsSync as existsSync6, statSync as statSync3, readdirSync, readFileSync as readFileSync2, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname6, resolve as resolve6, relative as relative2, join as join4, parse as parse2 } from "path";
 import { WebSocketServer, WebSocket } from "ws";
 import { watch } from "chokidar";
 import {
@@ -1792,7 +1792,563 @@ function completeBackgroundTask(id, successMessage, error) {
 }
 
 // src/commands/serve.ts
-import { ruleRegistry } from "uilint-eslint";
+import { ruleRegistry } from "uilint-eslint";
+
+// src/utils/eslint-utils.ts
+import { existsSync as existsSync5, readFileSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname5, resolve as resolve5, relative, join as join3 } from "path";
+
+// src/scope-extractor.ts
+import { createRequire } from "module";
+function isComponentName(name) {
+  if (!name) return false;
+  return /^[A-Z]/.test(name);
+}
+function isHookName(name) {
+  if (!name) return false;
+  return /^use[A-Z]/.test(name);
+}
+function containsJsxReturn(node) {
+  if (!node) return false;
+  if (node.type === "JSXElement" || node.type === "JSXFragment") {
+    return true;
+  }
+  if (node.type === "BlockStatement" && node.body) {
+    for (const stmt of node.body) {
+      if (stmt.type === "ReturnStatement" && stmt.argument) {
+        if (stmt.argument.type === "JSXElement" || stmt.argument.type === "JSXFragment") {
+          return true;
+        }
+        if (stmt.argument.type === "ConditionalExpression") {
+          if (stmt.argument.consequent?.type === "JSXElement" || stmt.argument.consequent?.type === "JSXFragment" || stmt.argument.alternate?.type === "JSXElement" || stmt.argument.alternate?.type === "JSXFragment") {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+function determineScopeType(name, isArrow, isMethod, returnsJsx, isExportDefault = false) {
+  if (isMethod) return "method";
+  if (isHookName(name)) return "hook";
+  if (isExportDefault && returnsJsx) return "component";
+  if (isComponentName(name) && returnsJsx) return "component";
+  if (isArrow) return "arrow-function";
+  return "function";
+}
+function getIdentifierName(node) {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "PrivateIdentifier") return `#${node.name}`;
+  return null;
+}
+function getJsxElementType(node) {
+  if (!node || node.type !== "JSXElement") return null;
+  const opening = node.openingElement;
+  if (!opening || !opening.name) return null;
+  const name = opening.name;
+  if (name.type === "JSXIdentifier") return name.name;
+  if (name.type === "JSXMemberExpression") {
+    const parts = [];
+    let current = name;
+    while (current) {
+      if (current.type === "JSXMemberExpression") {
+        parts.unshift(current.property.name);
+        current = current.object;
+      } else if (current.type === "JSXIdentifier") {
+        parts.unshift(current.name);
+        break;
+      } else {
+        break;
+      }
+    }
+    return parts.join(".");
+  }
+  return null;
+}
+function lineColToOffset(code, line, column) {
+  const lines = code.split("\n");
+  let offset = 0;
+  for (let i = 0; i < line - 1 && i < lines.length; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset + column;
+}
+function collectScopeBoundaries(ast) {
+  const boundaries = [];
+  function walk(node, parentName = null) {
+    if (!node || typeof node !== "object") return;
+    const range = node.range;
+    const loc = node.loc;
+    if (node.type === "FunctionDeclaration") {
+      const name = getIdentifierName(node.id);
+      const returnsJsx = containsJsxReturn(node.body);
+      const scopeType = determineScopeType(name, false, false, returnsJsx);
+      if (range && loc) {
+        boundaries.push({
+          name,
+          type: scopeType,
+          start: range[0],
+          end: range[1],
+          line: loc.start.line,
+          column: loc.start.column
+        });
+      }
+      walk(node.body, name);
+      return;
+    }
+    if (node.type === "ArrowFunctionExpression") {
+      let name = null;
+      const returnsJsx = containsJsxReturn(node.body);
+      if (range && loc) {
+        const scopeType = determineScopeType(name, true, false, returnsJsx);
+        boundaries.push({
+          name,
+          type: scopeType,
+          start: range[0],
+          end: range[1],
+          line: loc.start.line,
+          column: loc.start.column
+        });
+      }
+      walk(node.body, name || parentName);
+      return;
+    }
+    if (node.type === "FunctionExpression") {
+      const name = getIdentifierName(node.id);
+      const returnsJsx = containsJsxReturn(node.body);
+      const scopeType = determineScopeType(name, false, false, returnsJsx);
+      if (range && loc) {
+        boundaries.push({
+          name,
+          type: scopeType,
+          start: range[0],
+          end: range[1],
+          line: loc.start.line,
+          column: loc.start.column
+        });
+      }
+      walk(node.body, name || parentName);
+      return;
+    }
+    if (node.type === "VariableDeclarator" && node.init) {
+      const varName = getIdentifierName(node.id);
+      const init = node.init;
+      if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+        const funcOwnName = getIdentifierName(init.id);
+        const effectiveName = funcOwnName || varName;
+        const returnsJsx = containsJsxReturn(init.body);
+        const isArrow = init.type === "ArrowFunctionExpression";
+        const scopeType = determineScopeType(effectiveName, isArrow, false, returnsJsx);
+        const initRange = init.range;
+        const initLoc = init.loc;
+        if (initRange && initLoc) {
+          const existing = boundaries.find(
+            (b) => b.start === initRange[0] && b.end === initRange[1]
+          );
+          if (existing) {
+            existing.name = effectiveName;
+            existing.type = scopeType;
+          } else {
+            boundaries.push({
+              name: effectiveName,
+              type: scopeType,
+              start: initRange[0],
+              end: initRange[1],
+              line: initLoc.start.line,
+              column: initLoc.start.column
+            });
+          }
+        }
+        walk(init.body, effectiveName);
+        return;
+      }
+    }
+    if (node.type === "MethodDefinition" || node.type === "Property") {
+      const isMethod = node.type === "MethodDefinition" || node.type === "Property" && node.method;
+      if (isMethod && node.value) {
+        const name = getIdentifierName(node.key);
+        const returnsJsx = containsJsxReturn(node.value.body);
+        const scopeType = determineScopeType(name, false, true, returnsJsx);
+        if (range && loc) {
+          boundaries.push({
+            name,
+            type: scopeType,
+            start: range[0],
+            end: range[1],
+            line: loc.start.line,
+            column: loc.start.column
+          });
+        }
+        walk(node.value.body, name);
+        return;
+      }
+    }
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      const name = getIdentifierName(node.id);
+      if (range && loc) {
+        boundaries.push({
+          name,
+          type: "class",
+          start: range[0],
+          end: range[1],
+          line: loc.start.line,
+          column: loc.start.column
+        });
+      }
+      if (node.body) {
+        walk(node.body, name);
+      }
+      return;
+    }
+    if (node.type === "ExportDefaultDeclaration" && node.declaration) {
+      const decl = node.declaration;
+      if (decl.type === "FunctionDeclaration") {
+        const name = getIdentifierName(decl.id);
+        const returnsJsx = containsJsxReturn(decl.body);
+        const scopeType = determineScopeType(name, false, false, returnsJsx, !name);
+        const declRange = decl.range;
+        const declLoc = decl.loc;
+        if (declRange && declLoc) {
+          boundaries.push({
+            name: name || "default",
+            type: scopeType,
+            start: declRange[0],
+            end: declRange[1],
+            line: declLoc.start.line,
+            column: declLoc.start.column
+          });
+        }
+        walk(decl.body, name || "default");
+        return;
+      }
+      if (decl.type === "ClassDeclaration") {
+        walk(decl, parentName);
+        return;
+      }
+      if (decl.type === "FunctionExpression" || decl.type === "ArrowFunctionExpression") {
+        const funcOwnName = getIdentifierName(decl.id);
+        const name = funcOwnName || "default";
+        const returnsJsx = containsJsxReturn(decl.body);
+        const isArrow = decl.type === "ArrowFunctionExpression";
+        const scopeType = determineScopeType(name, isArrow, false, returnsJsx, !funcOwnName);
+        const declRange = decl.range;
+        const declLoc = decl.loc;
+        if (declRange && declLoc) {
+          boundaries.push({
+            name,
+            type: scopeType,
+            start: declRange[0],
+            end: declRange[1],
+            line: declLoc.start.line,
+            column: declLoc.start.column
+          });
+        }
+        walk(decl.body, name);
+        return;
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "range" || key === "parent") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item, parentName);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        walk(child, parentName);
+      }
+    }
+  }
+  walk(ast);
+  return boundaries;
+}
+function findContainingJsxElement(ast, offset) {
+  const result = {
+    innermost: null
+  };
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "JSXElement") {
+      const range = node.range;
+      if (range && range[0] <= offset && offset < range[1]) {
+        const size = range[1] - range[0];
+        if (!result.innermost || size < result.innermost.size) {
+          const elementType = getJsxElementType(node);
+          if (elementType) {
+            result.innermost = { type: elementType, size };
+          }
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "range" || key === "parent") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object" && child.type) {
+        walk(child);
+      }
+    }
+  }
+  walk(ast);
+  return result.innermost?.type ?? null;
+}
+function findEnclosingScopeBatch(source, positions, options) {
+  const localRequire2 = createRequire(import.meta.url);
+  const { parse: parse3 } = localRequire2("@typescript-eslint/typescript-estree");
+  let ast;
+  try {
+    ast = parse3(source, {
+      loc: true,
+      range: true,
+      jsx: true,
+      comment: false,
+      errorOnUnknownASTType: false
+    });
+  } catch {
+    return positions.map(() => null);
+  }
+  const boundaries = collectScopeBoundaries(ast);
+  return positions.map(({ line, column }) => {
+    const offset = lineColToOffset(source, line, column);
+    const containingScopes = boundaries.filter((b) => b.start <= offset && offset < b.end).sort((a, b) => a.end - a.start - (b.end - b.start));
+    const jsxElementType = findContainingJsxElement(ast, offset);
+    if (containingScopes.length === 0) {
+      return {
+        enclosingScope: null,
+        scopeType: "module",
+        jsxElementType: jsxElementType ?? void 0
+      };
+    }
+    const innermost = containingScopes[0];
+    const parent = containingScopes.length > 1 ? containingScopes[1] : null;
+    const scopeName = innermost.name || "anonymous";
+    return {
+      enclosingScope: scopeName,
+      scopeType: innermost.type,
+      parentScope: parent?.name ?? void 0,
+      jsxElementType: jsxElementType ?? void 0
+    };
+  });
+}
+
+// src/utils/eslint-utils.ts
+var ESLINT_CONFIG_FILES = [
+  // 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 buildLineStarts(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) {
+    if (code.charCodeAt(i) === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+function offsetFromLineCol(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 buildJsxElementSpans(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 mapMessageToDataLoc(params) {
+  const col0 = typeof params.messageCol1 === "number" ? Math.max(0, params.messageCol1 - 1) : 0;
+  const offset = offsetFromLineCol(
+    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 normalizePathSlashes(p) {
+  return p.replace(/\\/g, "/");
+}
+function normalizeDataLocFilePath(absoluteFilePath, projectCwd) {
+  const abs = normalizePathSlashes(resolve5(absoluteFilePath));
+  const cwd = normalizePathSlashes(resolve5(projectCwd));
+  if (abs === cwd || abs.startsWith(cwd + "/")) {
+    return normalizePathSlashes(relative(cwd, abs));
+  }
+  return abs;
+}
+function findESLintCwd(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 30; i++) {
+    for (const cfg of ESLINT_CONFIG_FILES) {
+      if (existsSync5(join3(dir, cfg))) return dir;
+    }
+    if (existsSync5(join3(dir, "package.json"))) return dir;
+    const parent = dirname5(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+var eslintInstances = /* @__PURE__ */ new Map();
+async function getESLintForProject(projectCwd) {
+  const cached = eslintInstances.get(projectCwd);
+  if (cached) return cached;
+  try {
+    const req = createRequire2(join3(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 });
+    eslintInstances.set(projectCwd, eslint);
+    return eslint;
+  } catch {
+    return null;
+  }
+}
+async function lintFileWithDataLoc(absolutePath, projectCwd, onProgress) {
+  const progress = onProgress ?? (() => {
+  });
+  if (!existsSync5(absolutePath)) {
+    progress(`File not found: ${absolutePath}`);
+    return [];
+  }
+  progress(`Resolving ESLint project... ${projectCwd}`);
+  const eslint = await getESLintForProject(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 = normalizeDataLocFilePath(absolutePath, projectCwd);
+    let spans = [];
+    let lineStarts = [];
+    let codeLength = 0;
+    let fileCode = null;
+    try {
+      progress("Building JSX map...");
+      fileCode = readFileSync(absolutePath, "utf-8");
+      codeLength = fileCode.length;
+      lineStarts = buildLineStarts(fileCode);
+      spans = buildJsxElementSpans(fileCode, dataLocFile);
+      progress(`JSX map: ${spans.length} element(s)`);
+    } catch (e) {
+      progress("JSX map failed (falling back to unmapped issues)");
+      spans = [];
+      lineStarts = [];
+      codeLength = 0;
+      fileCode = null;
+    }
+    let 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 ? mapMessageToDataLoc({
+        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`);
+    }
+    if (fileCode && issues.length > 0) {
+      progress("Extracting scope info...");
+      issues = enrichIssuesWithScopeInfo(issues, fileCode);
+      const scopeCount = issues.filter((i) => Boolean(i.scopeInfo)).length;
+      progress(`Enriched ${scopeCount}/${issues.length} issue(s) with scope info`);
+    }
+    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
+  };
+}
+function enrichIssuesWithScopeInfo(issues, code) {
+  if (issues.length === 0) {
+    return issues;
+  }
+  const positions = issues.map((issue) => ({
+    line: issue.line,
+    column: issue.column ?? 0
+  }));
+  const scopeInfos = findEnclosingScopeBatch(code, positions);
+  return issues.map((issue, index) => {
+    const scopeInfo = scopeInfos[index];
+    if (scopeInfo) {
+      return { ...issue, scopeInfo };
+    }
+    return issue;
+  });
+}
+
+// src/commands/serve.ts
 function pickAppRoot(params) {
   const { cwd, workspaceRoot } = params;
   if (detectNextAppRouter(cwd)) return cwd;
@@ -1806,10 +2362,10 @@ function pickAppRoot(params) {
   return matches[0].projectPath;
 }
 function detectPostToolUseHook(projectRoot) {
-  const claudeSettingsPath = join3(projectRoot, ".claude", "settings.json");
-  if (existsSync5(claudeSettingsPath)) {
+  const claudeSettingsPath = join4(projectRoot, ".claude", "settings.json");
+  if (existsSync6(claudeSettingsPath)) {
     try {
-      const content = readFileSync(claudeSettingsPath, "utf-8");
+      const content = readFileSync2(claudeSettingsPath, "utf-8");
       const settings = JSON.parse(content);
       const hooks = settings.hooks?.PostToolUse;
       if (Array.isArray(hooks)) {
@@ -1823,10 +2379,10 @@ function detectPostToolUseHook(projectRoot) {
     } catch {
     }
   }
-  const cursorHooksPath = join3(projectRoot, ".cursor", "hooks.json");
-  if (existsSync5(cursorHooksPath)) {
+  const cursorHooksPath = join4(projectRoot, ".cursor", "hooks.json");
+  if (existsSync6(cursorHooksPath)) {
     try {
-      const content = readFileSync(cursorHooksPath, "utf-8");
+      const content = readFileSync2(cursorHooksPath, "utf-8");
       const hooks = JSON.parse(content);
       if (hooks.hooks?.afterFileEdit?.length > 0) {
         return { enabled: true, provider: "cursor" };
@@ -1837,7 +2393,7 @@ function detectPostToolUseHook(projectRoot) {
   return { enabled: false, provider: null };
 }
 var cache = /* @__PURE__ */ new Map();
-var eslintInstances = /* @__PURE__ */ new Map();
+var eslintInstances2 = /* @__PURE__ */ new Map();
 var visionAnalyzer = null;
 function getVisionAnalyzerInstance() {
   if (!visionAnalyzer) {
@@ -1854,20 +2410,20 @@ var resolvedPathCache = /* @__PURE__ */ new Map();
 var subscriptions = /* @__PURE__ */ new Map();
 var fileWatcher = null;
 var connectedClients = 0;
-var localRequire = createRequire(import.meta.url);
-function buildLineStarts(code) {
+var localRequire = createRequire3(import.meta.url);
+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 offsetFromLineCol(lineStarts, line1, col0, codeLength) {
+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 buildJsxElementSpans(code, dataLocFile) {
+function buildJsxElementSpans2(code, dataLocFile) {
   const { parse: parse3 } = localRequire("@typescript-eslint/typescript-estree");
   const ast = parse3(code, {
     loc: true,
@@ -1901,9 +2457,9 @@ function buildJsxElementSpans(code, dataLocFile) {
   spans.sort((a, b) => a.end - a.start - (b.end - b.start));
   return spans;
 }
-function mapMessageToDataLoc(params) {
+function mapMessageToDataLoc2(params) {
   const col0 = typeof params.messageCol1 === "number" ? Math.max(0, params.messageCol1 - 1) : 0;
-  const offset = offsetFromLineCol(
+  const offset = offsetFromLineCol2(
     params.lineStarts,
     params.messageLine1,
     col0,
@@ -1914,7 +2470,7 @@ function mapMessageToDataLoc(params) {
   }
   return void 0;
 }
-var ESLINT_CONFIG_FILES = [
+var ESLINT_CONFIG_FILES2 = [
   // Flat config (ESLint v9+)
   "eslint.config.js",
   "eslint.config.mjs",
@@ -1928,57 +2484,57 @@ var ESLINT_CONFIG_FILES = [
   ".eslintrc.yaml",
   ".eslintrc.yml"
 ];
-function findESLintCwd(startDir) {
+function findESLintCwd2(startDir) {
   let dir = startDir;
   for (let i = 0; i < 30; i++) {
-    for (const cfg of ESLINT_CONFIG_FILES) {
-      if (existsSync5(join3(dir, cfg))) return dir;
+    for (const cfg of ESLINT_CONFIG_FILES2) {
+      if (existsSync6(join4(dir, cfg))) return dir;
     }
-    if (existsSync5(join3(dir, "package.json"))) return dir;
-    const parent = dirname5(dir);
+    if (existsSync6(join4(dir, "package.json"))) return dir;
+    const parent = dirname6(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return startDir;
 }
-function normalizePathSlashes(p) {
+function normalizePathSlashes2(p) {
   return p.replace(/\\/g, "/");
 }
-function normalizeDataLocFilePath(absoluteFilePath, projectCwd) {
-  const abs = normalizePathSlashes(resolve5(absoluteFilePath));
-  const cwd = normalizePathSlashes(resolve5(projectCwd));
+function normalizeDataLocFilePath2(absoluteFilePath, projectCwd) {
+  const abs = normalizePathSlashes2(resolve6(absoluteFilePath));
+  const cwd = normalizePathSlashes2(resolve6(projectCwd));
   if (abs === cwd || abs.startsWith(cwd + "/")) {
-    return normalizePathSlashes(relative(cwd, abs));
+    return normalizePathSlashes2(relative2(cwd, abs));
   }
   return abs;
 }
 function resolveRequestedFilePath(filePath) {
   if (filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath)) {
-    return resolve5(filePath);
+    return resolve6(filePath);
   }
   const cached = resolvedPathCache.get(filePath);
   if (cached) return cached;
   const cwd = process.cwd();
-  const fromCwd = resolve5(cwd, filePath);
-  if (existsSync5(fromCwd)) {
+  const fromCwd = resolve6(cwd, filePath);
+  if (existsSync6(fromCwd)) {
     resolvedPathCache.set(filePath, fromCwd);
     return fromCwd;
   }
   const wsRoot = findWorkspaceRoot4(cwd);
-  const fromWs = resolve5(wsRoot, filePath);
-  if (existsSync5(fromWs)) {
+  const fromWs = resolve6(wsRoot, filePath);
+  if (existsSync6(fromWs)) {
     resolvedPathCache.set(filePath, fromWs);
     return fromWs;
   }
   for (const top of ["apps", "packages"]) {
-    const base = join3(wsRoot, top);
-    if (!existsSync5(base)) continue;
+    const base = join4(wsRoot, top);
+    if (!existsSync6(base)) continue;
     try {
       const entries = readdirSync(base, { withFileTypes: true });
       for (const ent of entries) {
         if (!ent.isDirectory()) continue;
-        const p = resolve5(base, ent.name, filePath);
-        if (existsSync5(p)) {
+        const p = resolve6(base, ent.name, filePath);
+        if (existsSync6(p)) {
           resolvedPathCache.set(filePath, p);
           return p;
         }
@@ -1989,16 +2545,16 @@ function resolveRequestedFilePath(filePath) {
   resolvedPathCache.set(filePath, fromCwd);
   return fromCwd;
 }
-async function getESLintForProject(projectCwd) {
-  const cached = eslintInstances.get(projectCwd);
+async function getESLintForProject2(projectCwd) {
+  const cached = eslintInstances2.get(projectCwd);
   if (cached) return cached;
   try {
-    const req = createRequire(join3(projectCwd, "package.json"));
+    const req = createRequire3(join4(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 });
-    eslintInstances.set(projectCwd, eslint);
+    eslintInstances2.set(projectCwd, eslint);
     return eslint;
   } catch {
     return null;
@@ -2006,7 +2562,7 @@ async function getESLintForProject(projectCwd) {
 }
 async function lintFile(filePath, onProgress) {
   const absolutePath = resolveRequestedFilePath(filePath);
-  if (!existsSync5(absolutePath)) {
+  if (!existsSync6(absolutePath)) {
     onProgress(`File not found: ${pc.dim(absolutePath)}`);
     return [];
   }
@@ -2022,10 +2578,10 @@ async function lintFile(filePath, onProgress) {
     onProgress("Cache hit (unchanged)");
     return cached.issues;
   }
-  const fileDir = dirname5(absolutePath);
-  const projectCwd = findESLintCwd(fileDir);
+  const fileDir = dirname6(absolutePath);
+  const projectCwd = findESLintCwd2(fileDir);
   onProgress(`Resolving ESLint project... ${pc.dim(projectCwd)}`);
-  const eslint = await getESLintForProject(projectCwd);
+  const eslint = await getESLintForProject2(projectCwd);
   if (!eslint) {
     logWarning(
       `ESLint not found in project. Install it in ${pc.dim(
@@ -2039,16 +2595,17 @@ async function lintFile(filePath, onProgress) {
     onProgress("Running ESLint...");
     const results = await eslint.lintFiles([absolutePath]);
     const messages = Array.isArray(results) && results.length > 0 ? results[0].messages || [] : [];
-    const dataLocFile = normalizeDataLocFilePath(absolutePath, projectCwd);
+    const dataLocFile = normalizeDataLocFilePath2(absolutePath, projectCwd);
     let spans = [];
     let lineStarts = [];
     let codeLength = 0;
+    let fileCode = null;
     try {
       onProgress("Building JSX map...");
-      const code = readFileSync(absolutePath, "utf-8");
-      codeLength = code.length;
-      lineStarts = buildLineStarts(code);
-      spans = buildJsxElementSpans(code, dataLocFile);
+      fileCode = readFileSync2(absolutePath, "utf-8");
+      codeLength = fileCode.length;
+      lineStarts = buildLineStarts2(fileCode);
+      spans = buildJsxElementSpans2(fileCode, dataLocFile);
       onProgress(`JSX map: ${spans.length} element(s)`);
     } catch (e) {
       onProgress("JSX map failed (falling back to unmapped issues)");
@@ -2056,11 +2613,12 @@ async function lintFile(filePath, onProgress) {
       spans = [];
       lineStarts = [];
       codeLength = 0;
+      fileCode = null;
     }
-    const issues = messages.filter((m) => typeof m?.message === "string").map((m) => {
+    let 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 ? mapMessageToDataLoc({
+      const mappedDataLoc = spans.length > 0 && lineStarts.length > 0 && codeLength > 0 ? mapMessageToDataLoc2({
         spans,
         lineStarts,
         codeLength,
@@ -2081,6 +2639,12 @@ async function lintFile(filePath, onProgress) {
         `Mapped ${mappedCount}/${issues.length} issue(s) to JSX elements`
       );
     }
+    if (fileCode && issues.length > 0) {
+      onProgress("Extracting scope info...");
+      issues = enrichIssuesWithScopeInfo(issues, fileCode);
+      const scopeCount = issues.filter((i) => Boolean(i.scopeInfo)).length;
+      onProgress(`Enriched ${scopeCount}/${issues.length} issue(s) with scope info`);
+    }
     cache.set(absolutePath, { issues, mtimeMs, timestamp: Date.now() });
     return issues;
   } catch (error) {
@@ -2126,7 +2690,7 @@ async function handleMessage(ws, data) {
       });
       const startedAt = Date.now();
       const resolved = resolveRequestedFilePath(filePath);
-      if (!existsSync5(resolved)) {
+      if (!existsSync6(resolved)) {
         const cwd = process.cwd();
         const wsRoot = findWorkspaceRoot4(cwd);
         logServerWarning(
@@ -2278,14 +2842,14 @@ async function handleMessage(ws, data) {
               screenshotFile
             );
           } else {
-            const screenshotsDir = join3(
+            const screenshotsDir = join4(
               serverAppRootForVision,
               ".uilint",
               "screenshots"
             );
-            const imagePath = join3(screenshotsDir, screenshotFile);
+            const imagePath = join4(screenshotsDir, screenshotFile);
             try {
-              if (!existsSync5(imagePath)) {
+              if (!existsSync6(imagePath)) {
                 logServerWarning(
                   `Skipping vision report write: screenshot file not found`,
                   imagePath
@@ -2377,7 +2941,7 @@ async function handleMessage(ws, data) {
     case "source:fetch": {
       const { filePath, requestId } = message;
       const absolutePath = resolveRequestedFilePath(filePath);
-      if (!existsSync5(absolutePath)) {
+      if (!existsSync6(absolutePath)) {
         sendMessage(ws, {
           type: "source:error",
           filePath,
@@ -2387,9 +2951,9 @@ async function handleMessage(ws, data) {
         break;
       }
       try {
-        const content = readFileSync(absolutePath, "utf-8");
+        const content = readFileSync2(absolutePath, "utf-8");
         const totalLines = content.split("\n").length;
-        const relativePath = normalizeDataLocFilePath(absolutePath, serverAppRootForVision);
+        const relativePath = normalizeDataLocFilePath2(absolutePath, serverAppRootForVision);
         sendMessage(ws, {
           type: "source:result",
           filePath,
@@ -2411,8 +2975,8 @@ async function handleMessage(ws, data) {
     case "coverage:request": {
       const { requestId } = message;
       try {
-        const coveragePath = join3(serverAppRootForVision, "coverage", "coverage-final.json");
-        if (!existsSync5(coveragePath)) {
+        const coveragePath = join4(serverAppRootForVision, "coverage", "coverage-final.json");
+        if (!existsSync6(coveragePath)) {
           sendMessage(ws, {
             type: "coverage:error",
             error: "Coverage data not found. Run tests with coverage first (e.g., `vitest run --coverage`)",
@@ -2420,7 +2984,7 @@ async function handleMessage(ws, data) {
           });
           break;
         }
-        const coverageData = JSON.parse(readFileSync(coveragePath, "utf-8"));
+        const coverageData = JSON.parse(readFileSync2(coveragePath, "utf-8"));
         logCoverageResult(Object.keys(coverageData).length);
         sendMessage(ws, {
           type: "coverage:result",
@@ -2470,15 +3034,15 @@ async function handleMessage(ws, data) {
           });
           break;
         }
-        const screenshotsDir = join3(serverAppRootForVision, ".uilint", "screenshots");
-        if (!existsSync5(screenshotsDir)) {
+        const screenshotsDir = join4(serverAppRootForVision, ".uilint", "screenshots");
+        if (!existsSync6(screenshotsDir)) {
           mkdirSync4(screenshotsDir, { recursive: true });
         }
-        const imagePath = join3(screenshotsDir, filename);
+        const imagePath = join4(screenshotsDir, filename);
         const imageBuffer = Buffer.from(base64Data, "base64");
         writeFileSync4(imagePath, imageBuffer);
         const sidecarFilename = filename.replace(/\.png$/, ".json");
-        const sidecarPath = join3(screenshotsDir, sidecarFilename);
+        const sidecarPath = join4(screenshotsDir, sidecarFilename);
         const sidecarData = {
           route,
           timestamp,
@@ -2532,7 +3096,7 @@ function handleFileChange(filePath) {
 }
 function handleCoverageFileChange(filePath) {
   try {
-    const coverageData = JSON.parse(readFileSync(filePath, "utf-8"));
+    const coverageData = JSON.parse(readFileSync2(filePath, "utf-8"));
     logCoverageResult(Object.keys(coverageData).length);
     broadcast({
       type: "coverage:result",
@@ -2716,7 +3280,7 @@ function handleRuleConfigSet(ws, ruleId, severity, options, requestId) {
   }
   if (result.success) {
     logServerInfo(`Updated uilint/${normalizedRuleId} -> ${severity}`);
-    eslintInstances.clear();
+    eslintInstances2.clear();
     cache.clear();
     updateCacheCount(0);
     sendMessage(ws, {
@@ -2759,7 +3323,7 @@ async function serve(options) {
     ignoreInitial: true
   });
   fileWatcher.on("change", (path) => {
-    const resolvedPath = resolve5(path);
+    const resolvedPath = resolve6(path);
     if (resolvedPath.endsWith("coverage-final.json")) {
       handleCoverageFileChange(resolvedPath);
       return;
@@ -2767,8 +3331,8 @@ async function serve(options) {
     handleFileChange(resolvedPath);
     scheduleReindex(appRoot, resolvedPath);
   });
-  const coveragePath = join3(appRoot, "coverage", "coverage-final.json");
-  if (existsSync5(coveragePath)) {
+  const coveragePath = join4(appRoot, "coverage", "coverage-final.json");
+  if (existsSync6(coveragePath)) {
     fileWatcher.add(coveragePath);
     logServerInfo(`Watching coverage`, coveragePath);
   }
@@ -2862,10 +3426,10 @@ async function serve(options) {
 }
 
 // src/commands/vision.ts
-import { dirname as dirname6, resolve as resolve6, join as join4 } from "path";
+import { dirname as dirname7, resolve as resolve7, join as join5 } from "path";
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync2,
+  existsSync as existsSync7,
+  readFileSync as readFileSync3,
   readdirSync as readdirSync2
 } from "fs";
 import {
@@ -2892,7 +3456,7 @@ function debugDumpPath3(options) {
   const v = options.debugDump ?? process.env.UILINT_DEBUG_DUMP;
   if (!v) return null;
   if (v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes") {
-    return resolve6(process.cwd(), ".uilint");
+    return resolve7(process.cwd(), ".uilint");
   }
   return v;
 }
@@ -2911,17 +3475,17 @@ function debugLog3(enabled, message, obj) {
 function findScreenshotsDirUpwards(startDir) {
   let dir = startDir;
   for (let i = 0; i < 20; i++) {
-    const candidate = join4(dir, ".uilint", "screenshots");
-    if (existsSync6(candidate)) return candidate;
-    const parent = dirname6(dir);
+    const candidate = join5(dir, ".uilint", "screenshots");
+    if (existsSync7(candidate)) return candidate;
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function listScreenshotSidecars(dirPath) {
-  if (!existsSync6(dirPath)) return [];
-  const entries = readdirSync2(dirPath).filter((f) => f.endsWith(".json")).map((f) => join4(dirPath, f));
+  if (!existsSync7(dirPath)) return [];
+  const entries = readdirSync2(dirPath).filter((f) => f.endsWith(".json")).map((f) => join5(dirPath, f));
   const out = [];
   for (const p of entries) {
     try {
@@ -2950,11 +3514,11 @@ function listScreenshotSidecars(dirPath) {
   return out;
 }
 function readImageAsBase64(imagePath) {
-  const bytes = readFileSync2(imagePath);
+  const bytes = readFileSync3(imagePath);
   return { base64: bytes.toString("base64"), sizeBytes: bytes.byteLength };
 }
 function loadJsonFile(filePath) {
-  const raw = readFileSync2(filePath, "utf-8");
+  const raw = readFileSync3(filePath, "utf-8");
   return JSON.parse(raw);
 }
 function formatIssuesText(issues) {
@@ -3028,13 +3592,13 @@ async function vision(options) {
       await flushLangfuse();
       process.exit(1);
     }
-    if (imagePath && !existsSync6(imagePath)) {
+    if (imagePath && !existsSync7(imagePath)) {
       throw new Error(`Image not found: ${imagePath}`);
     }
-    if (sidecarPath && !existsSync6(sidecarPath)) {
+    if (sidecarPath && !existsSync7(sidecarPath)) {
       throw new Error(`Sidecar not found: ${sidecarPath}`);
     }
-    if (manifestFilePath && !existsSync6(manifestFilePath)) {
+    if (manifestFilePath && !existsSync7(manifestFilePath)) {
       throw new Error(`Manifest file not found: ${manifestFilePath}`);
     }
     const sidecar = sidecarPath ? loadJsonFile(sidecarPath) : null;
@@ -3059,7 +3623,7 @@ async function vision(options) {
       const resolved = await resolveVisionStyleGuide({
         projectPath,
         styleguide: options.styleguide,
-        startDir: startPath ? dirname6(startPath) : projectPath
+        startDir: startPath ? dirname7(startPath) : projectPath
       });
       styleGuide = resolved.styleGuide;
       styleguideLocation = resolved.styleguideLocation;
@@ -3108,8 +3672,8 @@ async function vision(options) {
     const resolvedImagePath = imagePath || (() => {
       const screenshotFile = typeof sidecar?.screenshotFile === "string" ? sidecar.screenshotFile : typeof sidecar?.filename === "string" ? sidecar.filename : void 0;
       if (!screenshotFile) return null;
-      const baseDir = sidecarPath ? dirname6(sidecarPath) : projectPath;
-      const abs = resolve6(baseDir, screenshotFile);
+      const baseDir = sidecarPath ? dirname7(sidecarPath) : projectPath;
+      const abs = resolve7(baseDir, screenshotFile);
       return abs;
     })();
     if (!resolvedImagePath) {
@@ -3117,7 +3681,7 @@ async function vision(options) {
         "No image path could be resolved. Provide --image or a sidecar with `screenshotFile`/`filename`."
       );
     }
-    if (!existsSync6(resolvedImagePath)) {
+    if (!existsSync7(resolvedImagePath)) {
       throw new Error(`Image not found: ${resolvedImagePath}`);
     }
     const { base64, sizeBytes } = readImageAsBase64(resolvedImagePath);
@@ -3667,14 +4231,17 @@ function indexCommand() {
 
 // src/commands/duplicates/find.ts
 import { Command as Command2 } from "commander";
-import { relative as relative2 } from "path";
+import { relative as relative3 } 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)",
+    "Similarity threshold 0-1 (default: 0.75)",
     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) => {
+  ).option("--min-size <n>", "Minimum group size (default: 2)", parseInt).option("--kind <type>", "Filter: component, hook, function").option(
+    "--confidence <level>",
+    "Minimum confidence: high, medium, low (default: low)"
+  ).option("--no-structural", "Disable structural similarity boost").option("--same-file", "Include duplicates within the same file").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";
@@ -3683,7 +4250,10 @@ function findCommand() {
         path: projectRoot,
         threshold: options.threshold,
         minGroupSize: options.minSize,
-        kind: options.kind
+        kind: options.kind,
+        confidenceLevel: options.confidence,
+        useStructuralBoost: options.structural !== false,
+        includeSameFile: options.sameFile ?? false
       });
       if (isJson) {
         console.log(JSON.stringify({ groups }, null, 2));
@@ -3701,24 +4271,23 @@ function findCommand() {
       );
       groups.forEach((group, idx) => {
         const similarity = Math.round(group.avgSimilarity * 100);
+        const confidenceEmoji = group.confidence === "high" ? "\u{1F534}" : group.confidence === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+        const confidenceColor = group.confidence === "high" ? chalk3.red : group.confidence === "medium" ? chalk3.yellow : chalk3.green;
         console.log(
-          chalk3.yellow(
-            `Duplicate Group ${idx + 1} (${similarity}% similar, ${group.members.length} occurrences):`
+          chalk3.bold(
+            `${confidenceEmoji} Duplicate Group ${idx + 1} (${confidenceColor(`${similarity}% - ${group.confidence} confidence`)}, ${group.members.length} occurrences):`
           )
         );
         group.members.forEach((member) => {
-          const relPath = relative2(projectRoot, member.filePath);
+          const relPath = relative3(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}
-`
-          )
-        );
+        const suggestion = group.confidence === "high" ? `Strongly recommend consolidating into a single reusable ${group.kind}` : group.confidence === "medium" ? `Consider extracting shared logic into a reusable ${group.kind}` : `Optional: Review if a common abstraction makes sense`;
+        console.log(chalk3.dim(`  \u2192 ${suggestion}
+`));
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -3734,7 +4303,7 @@ function findCommand() {
 
 // src/commands/duplicates/search.ts
 import { Command as Command3 } from "commander";
-import { relative as relative3 } from "path";
+import { relative as relative4 } 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) => {
@@ -3758,7 +4327,7 @@ function searchCommand() {
       console.log(chalk4.bold(`Found ${results.length} matching results:
 `));
       results.forEach((result, idx) => {
-        const relPath = relative3(projectRoot, result.filePath);
+        const relPath = relative4(projectRoot, result.filePath);
         const location = `${relPath}:${result.startLine}-${result.endLine}`;
         const name = result.name || "(anonymous)";
         const score = Math.round(result.score * 100);
@@ -3784,7 +4353,7 @@ function searchCommand() {
 
 // src/commands/duplicates/similar.ts
 import { Command as Command4 } from "commander";
-import { relative as relative4, resolve as resolve7, isAbsolute as isAbsolute2 } from "path";
+import { relative as relative5, resolve as resolve8, 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) => {
@@ -3813,7 +4382,7 @@ function similarCommand() {
       }
       process.exit(1);
     }
-    const filePath = isAbsolute2(filePart) ? filePart : resolve7(projectRoot, filePart);
+    const filePath = isAbsolute2(filePart) ? filePart : resolve8(projectRoot, filePart);
     try {
       const results = await findSimilarAtLocation({
         path: projectRoot,
@@ -3832,12 +4401,12 @@ function similarCommand() {
       }
       console.log(
         chalk5.bold(
-          `Found ${results.length} similar code locations to ${relative4(projectRoot, filePath)}:${line}:
+          `Found ${results.length} similar code locations to ${relative5(projectRoot, filePath)}:${line}:
 `
         )
       );
       results.forEach((result, idx) => {
-        const relPath = relative4(projectRoot, result.filePath);
+        const relPath = relative5(projectRoot, result.filePath);
         const locationStr = `${relPath}:${result.startLine}-${result.endLine}`;
         const name = result.name || "(anonymous)";
         const score = Math.round(result.score * 100);
@@ -3888,199 +4457,6 @@ 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/**",
@@ -4161,36 +4537,50 @@ async function generateManifest(options = {}) {
     const relativePath = relative6(cwd, absolutePath);
     onProgress(`Linting ${relativePath}...`, i + 1, files.length);
     const fileDir = dirname8(absolutePath);
-    const projectCwd = findESLintCwd2(fileDir);
+    const projectCwd = findESLintCwd(fileDir);
     const issues = await lintFileWithDataLoc(absolutePath, projectCwd);
     if (issues.length === 0) continue;
-    const manifestIssues = issues.filter((issue) => Boolean(issue.dataLoc)).map((issue) => ({
+    const filteredIssues = issues.filter(
+      (issue) => Boolean(issue.dataLoc)
+    );
+    if (filteredIssues.length === 0) continue;
+    let fileContent;
+    let snippets;
+    try {
+      fileContent = readFileSync4(absolutePath, "utf-8");
+    } catch {
+      fileContent = void 0;
+    }
+    let scopeInfos = [];
+    if (fileContent) {
+      try {
+        const positions = filteredIssues.map((issue) => ({
+          line: issue.line,
+          column: issue.column ?? 0
+        }));
+        scopeInfos = findEnclosingScopeBatch(fileContent, positions);
+      } catch {
+        scopeInfos = filteredIssues.map(() => null);
+      }
+    }
+    const manifestIssues = filteredIssues.map((issue, index) => ({
       line: issue.line,
       column: issue.column,
       message: issue.message,
       ruleId: issue.ruleId,
-      dataLoc: issue.dataLoc
+      dataLoc: issue.dataLoc,
+      scopeInfo: scopeInfos[index] ?? void 0
     }));
-    if (manifestIssues.length === 0) continue;
-    let fileContent;
-    let snippets;
-    if (includeSource || includeSnippets) {
-      try {
-        fileContent = readFileSync4(absolutePath, "utf-8");
-        if (includeSnippets) {
-          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(fileContent, issue.line, snippetContextLines);
-          }
+    if (includeSnippets && fileContent) {
+      snippets = {};
+      const issuesByDataLoc = /* @__PURE__ */ new Map();
+      for (const issue of manifestIssues) {
+        if (!issuesByDataLoc.has(issue.dataLoc)) {
+          issuesByDataLoc.set(issue.dataLoc, issue);
         }
-      } catch {
-        fileContent = void 0;
+      }
+      for (const [dataLoc, issue] of issuesByDataLoc) {
+        snippets[dataLoc] = extractSourceSnippet(fileContent, issue.line, snippetContextLines);
       }
     }
     for (const issue of manifestIssues) {
@@ -4207,7 +4597,7 @@ async function generateManifest(options = {}) {
       }
     }
     totalIssues += manifestIssues.length;
-    const dataLocFilePath = normalizeDataLocFilePath2(absolutePath, projectCwd);
+    const dataLocFilePath = normalizeDataLocFilePath(absolutePath, projectCwd);
     manifestFiles.push({
       filePath: dataLocFilePath,
       issues: manifestIssues,