scip-query 0.1.0 → 0.2.1

package/dist/chunk-34JPTNRN.js

@@ -0,0 +1,601 @@
+import {
+  findFirstSymbolMatch
+} from "./chunk-LLMPAG56.js";
+import {
+  isModuleLikeSymbol,
+  leafName,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/source-analysis.ts
+import {
+  existsSync,
+  readFileSync
+} from "fs";
+import {
+  dirname,
+  extname,
+  join,
+  relative,
+  resolve
+} from "path";
+var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
+var INDEXED_PATH_CACHE = /* @__PURE__ */ new WeakMap();
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var PYTHON_SOURCE_EXTENSIONS = [".py", ".pyi"];
+function getSourceImports(db, relativePath) {
+  const cache = getCachedMap(SOURCE_IMPORT_CACHE, db);
+  const normalized = normalizePath(relativePath);
+  const cached = cache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const fullPath = join(db.config.projectRoot, normalized);
+  if (!existsSync(fullPath)) {
+    cache.set(normalized, []);
+    return [];
+  }
+  const source = readFileSync(fullPath, "utf-8");
+  const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : parseJavaScriptImports(db, normalized, source);
+  cache.set(normalized, parsed);
+  return parsed;
+}
+function parseJavaScriptImports(db, importerPath, source) {
+  return parseJavaScriptImportStatements(source).flatMap((statement) => parseJavaScriptImportStatement(
+    db,
+    importerPath,
+    statement.clause,
+    statement.specifier,
+    statement.start,
+    statement.end,
+    source
+  ));
+}
+function parseJavaScriptImportStatements(source) {
+  const statements = [];
+  const importFromRegex = /^[ \t]*import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(importFromRegex)) {
+    const full = match[0];
+    const clause = match[1];
+    const specifier = match[2];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  const sideEffectRegex = /^[ \t]*import\s+['"]([^'"]+)['"]\s*;?/gm;
+  for (const match of source.matchAll(sideEffectRegex)) {
+    const full = match[0];
+    const specifier = match[1];
+    if (!full || !specifier || typeof match.index !== "number") continue;
+    statements.push({
+      clause: null,
+      specifier,
+      start: match.index,
+      end: match.index + full.length
+    });
+  }
+  return statements.sort((a, b) => a.start - b.start);
+}
+function parseJavaScriptImportStatement(db, importerPath, clause, specifier, start, end, source) {
+  const resolvedSource = resolveImportPath(db, importerPath, specifier);
+  const body = buildUsageBody(source, start, end);
+  if (!clause) {
+    return [{
+      importedName: "*",
+      localName: null,
+      sourcePath: resolvedSource,
+      kind: "side-effect",
+      used: true,
+      usedMembers: []
+    }];
+  }
+  const bindings = parseImportClause(clause).map((binding) => ({
+    ...binding,
+    sourcePath: resolvedSource
+  }));
+  return bindings.map((binding) => {
+    if (binding.kind === "namespace") {
+      const usedMembers = collectNamespaceMembers(body, binding.localName);
+      return {
+        ...binding,
+        used: usedMembers.length > 0 || hasIdentifierUsage(body, binding.localName),
+        usedMembers
+      };
+    }
+    if (binding.kind === "side-effect") {
+      return { ...binding, used: true, usedMembers: [] };
+    }
+    return {
+      ...binding,
+      used: binding.localName ? hasIdentifierUsage(body, binding.localName) : false,
+      usedMembers: []
+    };
+  });
+}
+function parsePythonImports(db, importerPath, source) {
+  return collectPythonImportStatements(source).flatMap(
+    (statement) => parsePythonImportStatement(db, importerPath, statement, source)
+  );
+}
+function collectPythonImportStatements(source) {
+  const lines = source.split("\n");
+  const statements = [];
+  let offset = 0;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const trimmed = line.trimStart();
+    const lineStart = offset;
+    offset += line.length + 1;
+    if (!trimmed.startsWith("import ") && !trimmed.startsWith("from ")) {
+      continue;
+    }
+    let statement = line;
+    let statementEnd = lineStart + line.length;
+    let balance = pythonParenBalance(line);
+    while (lineIndex + 1 < lines.length && (balance > 0 || statement.trimEnd().endsWith("\\"))) {
+      lineIndex++;
+      const nextLine = lines[lineIndex];
+      statement += `
+${nextLine}`;
+      statementEnd += 1 + nextLine.length;
+      balance += pythonParenBalance(nextLine);
+      offset += nextLine.length + 1;
+    }
+    const parsed = parsePythonStatementHeader(statement);
+    if (parsed) {
+      statements.push({
+        ...parsed,
+        start: lineStart,
+        end: statementEnd
+      });
+    }
+  }
+  return statements;
+}
+function parsePythonStatementHeader(statement) {
+  const normalized = statement.replace(/\\\s*\n/g, " ").trim();
+  if (normalized.startsWith("import ")) {
+    return {
+      kind: "import",
+      module: null,
+      clause: normalized.slice("import ".length).trim()
+    };
+  }
+  const fromMatch = normalized.match(/^from\s+([.\w]+)\s+import\s+([\s\S]+)$/);
+  if (!fromMatch) {
+    return null;
+  }
+  let clause = fromMatch[2].trim();
+  if (clause.startsWith("(") && clause.endsWith(")")) {
+    clause = clause.slice(1, -1).trim();
+  }
+  return {
+    kind: "from",
+    module: fromMatch[1],
+    clause
+  };
+}
+function parsePythonImportStatement(db, importerPath, statement, source) {
+  const body = buildUsageBody(source, statement.start, statement.end);
+  const normalizedClause = statement.clause.replace(/\n/g, " ").trim();
+  if (statement.kind === "import") {
+    return splitTopLevel(normalizedClause).flatMap((entry) => {
+      const cleaned = entry.trim().replace(/,$/, "");
+      if (!cleaned) return [];
+      const [moduleName, alias] = cleaned.split(/\s+as\s+/);
+      const importedName = moduleName.trim();
+      const localName = (alias ?? importedName.split(".")[0] ?? importedName).trim();
+      const sourcePath2 = resolvePythonImportPath(db, importerPath, importedName);
+      const usedMembers = collectNamespaceMembers(body, localName);
+      return [{
+        importedName,
+        localName,
+        sourcePath: sourcePath2,
+        kind: "namespace",
+        used: hasIdentifierUsage(body, localName) || usedMembers.length > 0,
+        usedMembers
+      }];
+    });
+  }
+  const sourcePath = statement.module ? resolvePythonImportPath(db, importerPath, statement.module) : null;
+  const results = [];
+  for (const entry of splitTopLevel(normalizedClause)) {
+    const cleaned = entry.trim().replace(/,$/, "");
+    if (!cleaned) continue;
+    if (cleaned === "*") {
+      results.push({
+        importedName: "*",
+        localName: null,
+        sourcePath,
+        kind: "side-effect",
+        used: true,
+        usedMembers: []
+      });
+      continue;
+    }
+    const [importedName, alias] = cleaned.split(/\s+as\s+/);
+    const localName = (alias ?? importedName).trim();
+    results.push({
+      importedName: importedName.trim(),
+      localName,
+      sourcePath,
+      kind: "named",
+      used: hasIdentifierUsage(body, localName),
+      usedMembers: []
+    });
+  }
+  return results;
+}
+function parseImportClause(clause) {
+  const trimmed = clause.trim().replace(/^type\s+/, "");
+  const [first, second] = splitImportClause(trimmed);
+  const entries = [];
+  if (first) {
+    entries.push(...parseImportBinding(first));
+  }
+  if (second) {
+    entries.push(...parseImportBinding(second));
+  }
+  return entries;
+}
+function parseImportBinding(binding) {
+  const trimmed = binding.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("{")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitTopLevel(inner).map((entry) => {
+      const cleaned = entry.trim().replace(/^type\s+/, "");
+      const [importedName, alias] = cleaned.split(/\s+as\s+/);
+      return {
+        importedName: importedName.trim(),
+        localName: (alias ?? importedName).trim(),
+        kind: "named"
+      };
+    });
+  }
+  if (trimmed.startsWith("* as ")) {
+    return [{
+      importedName: "*",
+      localName: trimmed.slice(5).trim(),
+      kind: "namespace"
+    }];
+  }
+  return [{
+    importedName: "default",
+    localName: trimmed,
+    kind: "default"
+  }];
+}
+function splitImportClause(clause) {
+  let depth = 0;
+  for (let i = 0; i < clause.length; i++) {
+    const char = clause[i];
+    if (char === "{") depth++;
+    if (char === "}") depth--;
+    if (char === "," && depth === 0) {
+      return [clause.slice(0, i).trim(), clause.slice(i + 1).trim()];
+    }
+  }
+  return [clause.trim(), null];
+}
+function splitTopLevel(input) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "{" || char === "[" || char === "(") depth++;
+    if (char === "}" || char === "]" || char === ")") depth--;
+    if (char === "," && depth === 0) {
+      parts.push(input.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(input.slice(start));
+  return parts;
+}
+function buildUsageBody(source, start, end) {
+  const masked = `${source.slice(0, start)}${" ".repeat(end - start)}${source.slice(end)}`;
+  return stripCommentsAndStrings(masked);
+}
+function stripCommentsAndStrings(source) {
+  return source.replace(/'''[\s\S]*?'''/g, " ").replace(/"""[\s\S]*?"""/g, " ").replace(/#.*$/gm, " ").replace(/\/\/.*$/gm, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/`(?:\\[\s\S]|[^`])*`/g, " ").replace(/'(?:\\.|[^'\\\r\n])*'/g, " ").replace(/"(?:\\.|[^"\\\r\n])*"/g, " ");
+}
+function hasIdentifierUsage(body, identifier) {
+  return new RegExp(`\\b${escapeRegex(identifier)}\\b`, "m").test(body);
+}
+function collectNamespaceMembers(body, namespaceName) {
+  const members = /* @__PURE__ */ new Set();
+  const regex = new RegExp(`\\b${escapeRegex(namespaceName)}\\s*\\.\\s*([A-Za-z_$][\\w$]*)`, "g");
+  for (const match of body.matchAll(regex)) {
+    const member = match[1];
+    if (member) {
+      members.add(member);
+    }
+  }
+  return [...members];
+}
+function resolveImportPath(db, importerPath, specifier) {
+  if (isPythonSourcePath(importerPath)) {
+    return resolvePythonImportPath(db, importerPath, specifier);
+  }
+  return resolveJavaScriptImportPath(db, importerPath, specifier);
+}
+function resolveJavaScriptImportPath(db, importerPath, specifier) {
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    return null;
+  }
+  const importerDir = dirname(join(db.config.projectRoot, importerPath));
+  const absolute = resolve(importerDir, specifier);
+  const indexedPaths = getIndexedPaths(db);
+  for (const candidate of candidateImportPaths(absolute)) {
+    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return normalizePath(relative(db.config.projectRoot, absolute));
+}
+function resolvePythonImportPath(db, importerPath, specifier) {
+  const indexedPaths = getIndexedPaths(db);
+  let basePath;
+  if (specifier.startsWith(".")) {
+    const match = specifier.match(/^(\.+)(.*)$/);
+    if (!match) return null;
+    const dots = match[1].length;
+    const remainder = match[2].replace(/^\./, "");
+    let baseDir = dirname(join(db.config.projectRoot, importerPath));
+    for (let i = 1; i < dots; i++) {
+      baseDir = dirname(baseDir);
+    }
+    basePath = remainder ? resolve(baseDir, remainder.replace(/\./g, "/")) : baseDir;
+  } else {
+    basePath = resolve(db.config.projectRoot, specifier.replace(/\./g, "/"));
+  }
+  for (const candidate of pythonCandidateImportPaths(basePath)) {
+    const relativeCandidate = normalizePath(relative(db.config.projectRoot, candidate));
+    if (indexedPaths.has(relativeCandidate) || existsSync(candidate)) {
+      return relativeCandidate;
+    }
+  }
+  return null;
+}
+function pythonCandidateImportPaths(basePath) {
+  const ext = extname(basePath);
+  if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
+    return [basePath];
+  }
+  return [
+    `${basePath}.py`,
+    `${basePath}.pyi`,
+    join(basePath, "__init__.py"),
+    join(basePath, "__init__.pyi")
+  ];
+}
+function candidateImportPaths(absolute) {
+  const ext = extname(absolute);
+  const candidates = /* @__PURE__ */ new Set();
+  if (ext) {
+    candidates.add(absolute);
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(absolute.slice(0, -ext.length) + sourceExt);
+    }
+  } else {
+    for (const sourceExt of SOURCE_EXTENSIONS) {
+      candidates.add(`${absolute}${sourceExt}`);
+      candidates.add(join(absolute, `index${sourceExt}`));
+    }
+  }
+  return [...candidates];
+}
+function getIndexedPaths(db) {
+  const cached = INDEXED_PATH_CACHE.get(db);
+  if (cached) {
+    return cached;
+  }
+  const paths = new Set(
+    db.all(
+      `SELECT relative_path
+       FROM documents
+       WHERE 1 = 1
+         ${db.pathExclusionsFor("documents")}`
+    ).map((row) => normalizePath(row.relative_path)).filter((relativePath) => !db.isIgnored(relativePath))
+  );
+  INDEXED_PATH_CACHE.set(db, paths);
+  return paths;
+}
+function getCachedMap(cache, db) {
+  let map = cache.get(db);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    cache.set(db, map);
+  }
+  return map;
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isPythonSourcePath(relativePath) {
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname(relativePath).toLowerCase());
+}
+function pythonParenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance++;
+    if (char === ")") balance--;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/queries/imports.ts
+function imports(db, filePattern) {
+  const rows = db.all(
+    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file, imp_d.relative_path AS importer
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents imp_d ON c.document_id = imp_d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    LEFT JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    LEFT JOIN documents def_d ON der.document_id = def_d.id
+    WHERE imp_d.relative_path LIKE ?
+      AND m.role = 2
+    ORDER BY def_d.relative_path, gs.symbol`,
+    `%${filePattern}%`
+  );
+  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    fromFile: r.from_file ?? "(external)"
+  }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const importer = findIndexedFile(db, filePattern);
+  if (!importer) return [];
+  return getSourceImports(db, importer).map((entry) => ({
+    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    fromFile: entry.sourcePath ?? "(external)"
+  }));
+}
+function importedBy(db, symbolPattern) {
+  const rows = db.all(
+    `SELECT DISTINCT gs.symbol, d.relative_path AS importer
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE gs.symbol LIKE ?
+      AND m.role = 2
+    ORDER BY d.relative_path`,
+    `%${symbolPattern}%`
+  );
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    fromFile: r.importer
+  }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const target = findFirstSymbolMatch(db, symbolPattern);
+  const targetFile = target?.relativePath ?? null;
+  const targetLeaf = target ? leafName(target.symbol) : symbolPattern.replace(/\(\)$/, "");
+  const targetIsModule = target ? isModuleLikeSymbol(target.symbol) : false;
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const importers = /* @__PURE__ */ new Set();
+  for (const row of files) {
+    if (db.isIgnored(row.relative_path)) continue;
+    for (const entry of getSourceImports(db, row.relative_path)) {
+      if (!entry.sourcePath) continue;
+      if (targetFile && normalizePath2(entry.sourcePath) !== normalizePath2(targetFile)) {
+        continue;
+      }
+      if (targetIsModule) {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (entry.kind === "named" && entry.importedName === targetLeaf) {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (entry.kind === "namespace" && entry.usedMembers.includes(targetLeaf)) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return [...importers].sort().map((importer) => ({
+    symbol: target?.symbol ?? targetLeaf,
+    shortName: target ? shortenSymbol(target.symbol) : targetLeaf,
+    fromFile: importer
+  }));
+}
+function unusedImports(db, filePattern) {
+  const rows = db.all(
+    `SELECT gs.symbol, d.relative_path AS imported_in, d.relative_path AS importer
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE d.relative_path LIKE ?
+      AND m.role = 2
+      AND NOT EXISTS (
+        SELECT 1
+        FROM mentions ref_m
+        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
+        WHERE ref_m.symbol_id = gs.id
+          AND ref_m.role != 1
+          AND ref_c.document_id = d.id
+      )
+    ORDER BY d.relative_path, gs.symbol`,
+    `%${filePattern}%`
+  );
+  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    importedIn: r.imported_in
+  }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const importer = findIndexedFile(db, filePattern);
+  if (!importer) return [];
+  return getSourceImports(db, importer).filter((entry) => entry.kind !== "side-effect" && !entry.used).map((entry) => ({
+    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
+    importedIn: importer
+  }));
+}
+function findIndexedFile(db, filePattern) {
+  const doc = db.get(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE ?
+       ${db.pathExclusionsFor("documents")}
+     LIMIT 1`,
+    `%${filePattern}%`
+  );
+  if (!doc || db.isIgnored(doc.relative_path)) {
+    return null;
+  }
+  return doc.relative_path;
+}
+function renderImportSymbol(importedName, localName, kind) {
+  if (kind === "namespace" && importedName === "*" && localName) {
+    return `* as ${localName}`;
+  }
+  if (kind === "default" && localName) {
+    return `default as ${localName}`;
+  }
+  if (kind === "side-effect") {
+    return "(side effect import)";
+  }
+  if (localName && localName !== importedName) {
+    return `${importedName} as ${localName}`;
+  }
+  return importedName;
+}
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/");
+}
+
+export {
+  imports,
+  importedBy,
+  unusedImports
+};
+//# sourceMappingURL=chunk-34JPTNRN.js.map

package/dist/{chunk-NDSQYIWT.js → chunk-3566TKJ5.js}

@@ -1,10 +1,10 @@
 import {
   getCalleeRowsForSymbol,
   testFileExclusionSql
-} from "./chunk-FUHJCHS4.js";
+} from "./chunk-LLMPAG56.js";
 import {
   shortenSymbol
-} from "./chunk-QOV2R2WT.js";
+} from "./chunk-QIXNAB5K.js";
 
 // src/queries/passthrough-candidates.ts
 function passthroughCandidates(db, opts) {
@@ -68,4 +68,4 @@ function passthroughCandidates(db, opts) {
 export {
   passthroughCandidates
 };
-//# sourceMappingURL=chunk-NDSQYIWT.js.map
+//# sourceMappingURL=chunk-3566TKJ5.js.map

package/dist/{chunk-LB7OS35Q.js → chunk-4ACRRQC4.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-FUHJCHS4.js";
+} from "./chunk-LLMPAG56.js";
 import {
   shortenSymbol
-} from "./chunk-QOV2R2WT.js";
+} from "./chunk-QIXNAB5K.js";
 
 // src/queries/convergence.ts
 function convergence(db, symbolPatternA, symbolPatternB) {
@@ -32,7 +32,11 @@ function convergence(db, symbolPatternA, symbolPatternB) {
   const union = /* @__PURE__ */ new Set([...calleesA, ...calleesB]);
   const similarity = union.size > 0 ? shared.length / union.size : 0;
   let strategy;
-  if (uniqueA.length === 0 && uniqueB.length === 0) {
+  if (union.size === 0) {
+    strategy = "Neither function calls other tracked symbols. There is no callee-pattern evidence for consolidation; inspect the source bodies directly.";
+  } else if (shared.length === 0) {
+    strategy = "These functions do not share any callees. They are not a callee-based consolidation candidate.";
+  } else if (uniqueA.length === 0 && uniqueB.length === 0) {
     strategy = "These functions have identical callee sets. One can replace the other directly.";
   } else if (uniqueA.length === 0) {
     strategy = `A is a subset of B. A can be replaced by calling B (B does everything A does plus more).`;
@@ -69,4 +73,4 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 export {
   convergence
 };
-//# sourceMappingURL=chunk-LB7OS35Q.js.map
+//# sourceMappingURL=chunk-4ACRRQC4.js.map

package/dist/{chunk-3E2X7RIE.js → chunk-4BQFSNFI.js}

@@ -1,6 +1,9 @@
+import {
+  isLiveBarrel
+} from "./chunk-VO4QI3LS.js";
 import {
   shortenSymbol
-} from "./chunk-QOV2R2WT.js";
+} from "./chunk-QIXNAB5K.js";
 
 // src/queries/redundant-reexports.ts
 function redundantReexports(db, opts = {}) {
@@ -20,7 +23,7 @@ function redundantReexports(db, opts = {}) {
     JOIN global_symbols gs ON m.symbol_id = gs.id
     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
     JOIN documents orig_d ON der.document_id = orig_d.id
-    WHERE m.role = 0
+    WHERE m.role != 1
       AND (barrel_d.relative_path LIKE '%/index.ts'
         OR barrel_d.relative_path LIKE '%/index.js'
         OR barrel_d.relative_path = 'index.ts'
@@ -36,6 +39,7 @@ function redundantReexports(db, opts = {}) {
   const results = [];
   for (const row of reexportRows) {
     if (db.isIgnored(row.barrel_path) || db.isIgnored(row.original_path)) continue;
+    if (isLiveBarrel(db, row.barrel_path)) continue;
     const consumerCounts = db.get(
       `SELECT
         SUM(CASE WHEN uses_barrel = 1 THEN 1 ELSE 0 END) AS barrel_consumers,
@@ -48,20 +52,20 @@ function redundantReexports(db, opts = {}) {
             FROM mentions barrel_m
             JOIN chunks barrel_c ON barrel_m.chunk_id = barrel_c.id
             WHERE barrel_c.document_id = consumer_d.id
-              AND barrel_m.role = 0
+              AND barrel_m.role != 1
               AND barrel_m.symbol_id IN (
                 SELECT m2.symbol_id
                 FROM mentions m2
                 JOIN chunks c2 ON m2.chunk_id = c2.id
                 WHERE c2.document_id = ?
-                  AND m2.role = 0
+                  AND m2.role != 1
               )
           ) THEN 1 ELSE 0 END) AS uses_barrel
         FROM mentions ref_m
         JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
         JOIN documents consumer_d ON ref_c.document_id = consumer_d.id
         WHERE ref_m.symbol_id = ?
-          AND ref_m.role = 0
+          AND ref_m.role != 1
           AND consumer_d.id != ?
           AND consumer_d.id != ?
           ${db.pathExclusionsFor("consumer_d")}
@@ -98,4 +102,4 @@ function redundantReexports(db, opts = {}) {
 export {
   redundantReexports
 };
-//# sourceMappingURL=chunk-3E2X7RIE.js.map
+//# sourceMappingURL=chunk-4BQFSNFI.js.map