@aiderdesk/tree-sitter-utils 0.1.0 → 0.2.0

package/dist/index.js

@@ -97,6 +97,7 @@ __export(index_exports, {
   CacheManager: () => CacheManager,
   GraphBuilder: () => GraphBuilder,
   PageRankCalculator: () => PageRankCalculator,
+  RepoMapService: () => RepoMapService,
   SymbolExtractor: () => SymbolExtractor,
   TreeRenderer: () => TreeRenderer,
   TreeSitterAnalyzer: () => TreeSitterAnalyzer,
@@ -116,6 +117,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/tree-sitter-analyzer.ts
+var path9 = __toESM(require("path"));
+
 // src/tree-sitter-parser.ts
 var fs2 = __toESM(require("fs/promises"));
 var path4 = __toESM(require("path"));
@@ -210,8 +214,8 @@ var LANGUAGE_WASM_MAP = {
     file: "tree-sitter-ocaml_interface.wasm"
   },
   c_sharp: {
-    url: "https://unpkg.com/tree-sitter-c-sharp/tree-sitter-c_sharp.wasm",
-    file: "tree-sitter-c_sharp.wasm"
+    url: "https://unpkg.com/tree-sitter-c-sharp@0.23.5/tree-sitter-c_sharp.wasm",
+    file: "tree-sitter-c_sharp-0.23.5.wasm"
   },
   haskell: {
     url: "https://unpkg.com/tree-sitter-haskell/tree-sitter-haskell.wasm",
@@ -223,11 +227,11 @@ var LANGUAGE_WASM_MAP = {
   }
 };
 function getCacheDir() {
-  const platform3 = os.platform();
+  const platform2 = os.platform();
   const homeDir = os.homedir();
-  if (platform3 === "darwin") {
+  if (platform2 === "darwin") {
     return path2.join(homeDir, "Library", "Caches", "aiderdesk", "tree-sitter");
-  } else if (platform3 === "win32") {
+  } else if (platform2 === "win32") {
     return path2.join(process.env.APPDATA || path2.join(homeDir, "AppData", "Roaming"), "aiderdesk", "tree-sitter");
   } else {
     return path2.join(homeDir, ".cache", "aiderdesk", "tree-sitter");
@@ -286,175 +290,179 @@ var QUERIES_DIR = path3.join(RESOURCES_DIR, "queries");
 var WASM_DIR = path3.join(RESOURCES_DIR, "wasm");
 
 // src/tree-sitter-parser.ts
+var runtimeInitialization;
 var TreeSitterParser = class {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parser = null;
   languages = /* @__PURE__ */ new Map();
-  queries = /* @__PURE__ */ new Map();
-  initialized = false;
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    try {
-      await import_web_tree_sitter.Parser.init();
-      this.parser = new import_web_tree_sitter.Parser();
-      try {
-        const queryFiles = await fs2.readdir(QUERIES_DIR);
-        for (const file of queryFiles) {
-          if (file.endsWith("-tags.scm")) {
-            const language = file.replace("-tags.scm", "");
-            const queryPath = path4.join(QUERIES_DIR, file);
-            const queryContent = await fs2.readFile(queryPath, "utf-8");
-            this.queries.set(language, queryContent);
+  initialization;
+  queue = Promise.resolve();
+  initialize() {
+    this.initialization ??= this.initializeParser();
+    return this.initialization;
+  }
+  async initializeParser() {
+    runtimeInitialization ??= import_web_tree_sitter.Parser.init();
+    await runtimeInitialization;
+    this.parser = new import_web_tree_sitter.Parser();
+  }
+  loadLanguage(name) {
+    let pending = this.languages.get(name);
+    if (!pending) {
+      pending = (async () => {
+        const buffer = await downloadWasmForLanguage(name);
+        if (!buffer) {
+          throw new Error(`No WASM available for ${name}`);
+        }
+        const language = await import_web_tree_sitter.Language.load(buffer);
+        const source = await fs2.readFile(path4.join(QUERIES_DIR, `${name}-tags.scm`), "utf-8");
+        const query = new import_web_tree_sitter.Query(language, source);
+        if (name === "c_sharp") {
+          for (const capture of query.captureNames) {
+            if (!capture.startsWith("name.")) query.disableCapture(capture);
           }
         }
-      } catch (error) {
-        logger_default.warn("[TreeSitterParser] Could not load query files from resources:", error);
-      }
-      this.initialized = true;
-      logger_default.info(`[TreeSitterParser] Initialized with ${this.queries.size} language queries`);
-    } catch (error) {
-      logger_default.error("[TreeSitterParser] Initialization failed:", error);
-      throw error;
+        return { language, query };
+      })();
+      this.languages.set(name, pending);
+      void pending.catch(() => this.languages.delete(name));
     }
+    return pending;
   }
-  async loadLanguage(language) {
-    if (this.languages.has(language)) {
-      return this.languages.get(language);
-    }
-    try {
-      const wasmBuffer = await downloadWasmForLanguage(language);
-      if (!wasmBuffer) {
-        return null;
-      }
-      const lang = await import_web_tree_sitter.Language.load(wasmBuffer);
-      this.languages.set(language, lang);
-      return lang;
-    } catch (error) {
-      logger_default.error(`[TreeSitterParser] Failed to load language ${language}:`, error);
-      return null;
-    }
+  parseFile(filePath, rootDir, compactReferences = false) {
+    const result = this.queue.then(() => this.parse(filePath, rootDir, compactReferences));
+    this.queue = result.catch(() => void 0);
+    return result;
   }
-  async parseFile(filePath, rootDir) {
-    if (!this.initialized || !this.parser) {
-      await this.initialize();
-    }
-    if (!this.parser) {
+  async parse(filePath, rootDir, compactReferences = false) {
+    await this.initialize();
+    const name = detectLanguage(filePath);
+    if (!name || !this.parser) {
       return [];
     }
-    const language = detectLanguage(filePath);
-    if (!language) {
-      return [];
-    }
-    const lang = await this.loadLanguage(language);
-    if (!lang) {
-      return [];
-    }
-    const query = this.queries.get(language);
-    if (!query) {
-      return [];
+    const { language, query } = await this.loadLanguage(name);
+    const source = await fs2.readFile(filePath, "utf-8");
+    this.parser.setLanguage(language);
+    const tree = this.parser.parse(source);
+    if (!tree) {
+      throw new Error(`Unable to parse ${filePath}`);
     }
     try {
-      const sourceCode = await fs2.readFile(filePath, "utf-8");
-      this.parser.setLanguage(lang);
-      const tree = this.parser.parse(sourceCode);
-      if (!tree) {
-        return [];
-      }
-      const tags = this.extractTags(tree.rootNode, query, filePath, lang, rootDir);
-      return tags;
-    } catch (error) {
-      logger_default.error(`[TreeSitterParser] Error parsing file ${filePath}:`, error);
-      return [];
-    }
-  }
-  extractTags(node, query, filePath, language, rootDir) {
-    const tags = [];
-    try {
-      const queryObj = new import_web_tree_sitter.Query(language, query);
-      const matches = queryObj.matches(node);
-      logger_default.debug(`[TreeSitterParser] Found ${matches.length} matches in ${filePath}`);
-      const relFname = rootDir ? path4.relative(rootDir, filePath) : filePath;
-      for (const match of matches) {
+      const tags = [];
+      const references = /* @__PURE__ */ new Map();
+      const relative5 = rootDir ? path4.relative(rootDir, filePath).replaceAll(path4.sep, "/") : filePath;
+      for (const match of query.matches(tree.rootNode)) {
         for (const capture of match.captures) {
-          if (!capture.name.startsWith("name.")) {
-            continue;
+          if (capture.name.startsWith("name.")) {
+            const kind = capture.name.includes("definition") ? "def" : "ref";
+            const name2 = capture.node.text;
+            const previous = compactReferences && kind === "ref" ? references.get(name2) : void 0;
+            if (previous) {
+              previous.count = (previous.count ?? 1) + 1;
+              continue;
+            }
+            const tag = {
+              rel_fname: relative5,
+              fname: filePath,
+              line: capture.node.startPosition.row,
+              // Detach sliced node text so cached tags cannot retain entire source files.
+              name: Buffer.from(name2, "utf8").toString("utf8"),
+              kind
+            };
+            tags.push(tag);
+            if (compactReferences && kind === "ref") references.set(tag.name, tag);
           }
-          const name = capture.node.text;
-          const kind = this.determineKind(capture.name);
-          const line = capture.node.startPosition.row;
-          logger_default.debug(`[TreeSitterParser] Found tag: ${name} (${kind}) at line ${line}`);
-          tags.push({
-            rel_fname: relFname,
-            fname: filePath,
-            line,
-            name,
-            kind
-          });
         }
       }
-    } catch (error) {
-      logger_default.error(`[TreeSitterParser] Error extracting tags from ${filePath}:`, error);
+      return tags;
+    } finally {
+      tree.delete();
     }
-    return tags;
   }
-  determineKind(captureName) {
-    if (captureName.includes("definition")) {
-      return "def";
+  async dispose() {
+    await this.queue;
+    for (const pending of this.languages.values()) {
+      try {
+        const { query } = await pending;
+        query.delete();
+      } catch {
+      }
     }
-    return "ref";
+    this.languages.clear();
+    this.parser?.delete();
+    this.parser = null;
+    this.initialization = void 0;
   }
 };
 
 // src/symbol-extractor.ts
+var fs3 = __toESM(require("fs/promises"));
+var path5 = __toESM(require("path"));
 init_language_detector();
 var SymbolExtractor = class {
   constructor(parser) {
     this.parser = parser;
   }
   cacheManager = null;
+  memory = /* @__PURE__ */ new Map();
+  lastRoot;
+  lastFiles = "";
+  revision = 0;
   setCacheManager(cacheManager) {
     this.cacheManager = cacheManager;
   }
-  async extractTags(files, rootDir) {
+  async extractTags(files, rootDir, signal, compactReferences = false) {
     const allTags = [];
-    const supportedFiles = files.filter(isLanguageSupported);
-    logger_default.info(`[SymbolExtractor] Extracting tags from ${supportedFiles.length} supported files out of ${files.length} total`);
-    const batchSize = 50;
-    for (let i = 0; i < supportedFiles.length; i += batchSize) {
-      const batch = supportedFiles.slice(i, i + batchSize);
-      const batchTags = await Promise.all(
-        batch.map(async (file) => {
+    const supported = files.filter(isLanguageSupported);
+    const fileKey = JSON.stringify([compactReferences, supported]);
+    if (this.lastRoot !== rootDir || this.lastFiles !== fileKey) {
+      this.revision++;
+      this.memory.clear();
+      this.lastRoot = rootDir;
+      this.lastFiles = fileKey;
+    }
+    for (let i = 0; i < supported.length; i += 50) {
+      signal?.throwIfAborted();
+      const results = await Promise.all(
+        supported.slice(i, i + 50).map(async (file) => {
           try {
-            if (this.cacheManager) {
-              const currentMtime = await this.cacheManager.getFileMtime(file);
-              if (currentMtime !== null) {
-                const cached = await this.cacheManager.getFileCache(file);
-                if (cached && cached.mtime === currentMtime) {
-                  logger_default.debug(`[SymbolExtractor] Cache hit for ${file}`);
-                  if (rootDir) {
-                    const path7 = await import("path");
-                    const relPath = path7.relative(rootDir, file);
-                    return cached.tags.map((tag) => ({ ...tag, rel_fname: relPath }));
-                  }
-                  return cached.tags;
-                }
-                const tags = await this.parser.parseFile(file, rootDir);
-                await this.cacheManager.setFileCache(file, currentMtime, tags);
+            const before = await fs3.stat(file);
+            const fingerprint = `${compactReferences}:${before.mtimeMs}:${before.ctimeMs}:${before.size}`;
+            const memory = this.memory.get(file);
+            if (this.cacheManager && memory?.fingerprint === fingerprint) {
+              return memory.tags;
+            }
+            this.revision++;
+            const cached = await this.cacheManager?.getFileCache(file);
+            let tags;
+            if (cached?.fingerprint === fingerprint) {
+              const relative5 = rootDir ? path5.relative(rootDir, file).replaceAll(path5.sep, "/") : file;
+              tags = cached.tags.map((tag) => ({
+                ...tag,
+                rel_fname: relative5
+              }));
+            } else {
+              tags = await this.parser.parseFile(file, rootDir, compactReferences);
+              const after = await fs3.stat(file);
+              if (`${compactReferences}:${after.mtimeMs}:${after.ctimeMs}:${after.size}` !== fingerprint) {
                 return tags;
               }
+              await this.cacheManager?.setFileCache(file, before.mtimeMs, tags, fingerprint);
             }
-            return await this.parser.parseFile(file, rootDir);
+            this.memory.set(file, { fingerprint, tags });
+            return tags;
           } catch (error) {
+            this.revision++;
+            this.memory.delete(file);
             logger_default.error(`[SymbolExtractor] Error processing ${file}:`, error);
             return [];
           }
         })
       );
-      allTags.push(...batchTags.flat());
+      for (const tags of results) {
+        for (const tag of tags) allTags.push(tag);
+      }
     }
-    logger_default.info(`[SymbolExtractor] Extracted ${allTags.length} tags total`);
+    signal?.throwIfAborted();
     return allTags;
   }
   filterDefinitions(tags) {
@@ -474,163 +482,93 @@ var SymbolExtractor = class {
   }
 };
 
-// src/graph-builder.ts
-var import_graphology = __toESM(require("graphology"));
-var GraphBuilder = class {
-  buildDependencyGraph(tags) {
-    const graph = new import_graphology.default({ type: "directed", allowSelfLoops: false, multi: true });
-    const defines = /* @__PURE__ */ new Map();
-    const references = /* @__PURE__ */ new Map();
+// src/dependency-index.ts
+var DependencyIndex = class {
+  definitions = [];
+  relations = [];
+  outbound = /* @__PURE__ */ new Map();
+  constructor(tags) {
     const definitions = /* @__PURE__ */ new Map();
+    const references = /* @__PURE__ */ new Map();
     for (const tag of tags) {
       if (tag.kind === "def") {
-        if (!defines.has(tag.name)) {
-          defines.set(tag.name, /* @__PURE__ */ new Set());
-        }
-        defines.get(tag.name).add(tag.rel_fname);
-        const key = `${tag.rel_fname}:${tag.name}`;
-        if (!definitions.has(key)) {
-          definitions.set(key, []);
-        }
-        definitions.get(key).push(tag);
-      } else if (tag.kind === "ref") {
-        if (!references.has(tag.name)) {
-          references.set(tag.name, []);
-        }
-        references.get(tag.name).push(tag.rel_fname);
+        this.definitions.push(tag);
+        let files = definitions.get(tag.name);
+        if (!files) definitions.set(tag.name, files = /* @__PURE__ */ new Set());
+        files.add(tag.rel_fname);
+        this.outbound.set(tag.rel_fname, 0);
+      } else {
+        let counts = references.get(tag.name);
+        if (!counts) references.set(tag.name, counts = /* @__PURE__ */ new Map());
+        counts.set(tag.rel_fname, (counts.get(tag.rel_fname) ?? 0) + (tag.count ?? 1));
       }
     }
-    const idents = new Set(Array.from(defines.keys()).filter((k) => references.has(k)));
-    for (const ident of Array.from(idents)) {
-      const definers = Array.from(defines.get(ident) || []);
-      const referencers = references.get(ident) || [];
-      let mul = 1;
-      if (this.isSnakeCase(ident) || this.isKebabCase(ident) || this.isCamelCase(ident)) {
-        mul *= 10;
-      }
-      if (ident.startsWith("_")) {
-        mul *= 0.1;
-      }
-      if (definers.length > 5) {
-        mul *= 0.1;
-      }
-      const refCounts = /* @__PURE__ */ new Map();
-      for (const ref of referencers) {
-        refCounts.set(ref, (refCounts.get(ref) || 0) + 1);
-      }
-      for (const referencer of referencers) {
-        const numRefs = refCounts.get(referencer) || 1;
-        const weight = mul * Math.sqrt(numRefs);
-        for (const definer of definers) {
-          if (referencer !== definer) {
-            if (!graph.hasNode(referencer)) {
-              graph.addNode(referencer);
-            }
-            if (!graph.hasNode(definer)) {
-              graph.addNode(definer);
-            }
-            const edgeKey = `${referencer}->${definer}:${ident}`;
-            if (!graph.hasEdge(edgeKey)) {
-              graph.addEdgeWithKey(edgeKey, referencer, definer, { weight, ident });
-            }
-          }
-        }
+    for (const [name, definers] of definitions) {
+      const counts = references.get(name);
+      if (!counts) continue;
+      let multiplier = 1;
+      if (/^[a-z][a-z0-9_]*$/.test(name) && name.includes("_") || /^[a-z][a-z0-9-]*$/.test(name) && name.includes("-") || /^[a-z][a-zA-Z0-9]*$/.test(name) && /[A-Z]/.test(name))
+        multiplier *= 10;
+      if (name.startsWith("_")) multiplier *= 0.1;
+      if (definers.size > 5) multiplier *= 0.1;
+      const sources = /* @__PURE__ */ new Map();
+      for (const [file, count] of counts) {
+        const targets = definers.size - Number(definers.has(file));
+        if (!targets) continue;
+        const weight = multiplier * Math.sqrt(count);
+        sources.set(file, weight);
+        this.outbound.set(file, (this.outbound.get(file) ?? 0) + weight * targets);
       }
+      if (sources.size) this.relations.push({ definers, sources });
     }
-    logger_default.info(`[GraphBuilder] Built graph with ${graph.order} nodes and ${graph.size} edges`);
-    return { graph, defines, references };
-  }
-  isSnakeCase(str) {
-    return /^[a-z][a-z0-9_]*$/.test(str) && str.includes("_");
   }
-  isKebabCase(str) {
-    return /^[a-z][a-z0-9-]*$/.test(str) && str.includes("-");
-  }
-  isCamelCase(str) {
-    return /^[a-z][a-zA-Z0-9]*$/.test(str) && /[A-Z]/.test(str);
-  }
-};
-
-// src/pagerank.ts
-var import_pagerank = __toESM(require("graphology-metrics/centrality/pagerank"));
-var PageRankCalculator = class {
-  calculate(graph, tags, mentionedFiles, mentionedIdents) {
-    if (graph.order === 0) {
-      return [];
-    }
-    const personalization = {};
-    const nodes = graph.nodes();
-    const personalize = nodes.length > 0 ? 100 / nodes.length : 0;
-    for (const node of nodes) {
-      let score = 0;
-      if (mentionedFiles?.has(node)) {
-        score += personalize;
+  rank(mentionedFiles = /* @__PURE__ */ new Set(), mentionedIdents = /* @__PURE__ */ new Set()) {
+    const nodes = [...this.outbound.keys()];
+    const count = nodes.length;
+    if (!count) return [];
+    const mentionedDefinitions = new Set(this.definitions.filter((tag) => mentionedIdents.has(tag.name)).map((tag) => tag.rel_fname));
+    const weights = new Map(nodes.map((node) => [node, Number(mentionedFiles.has(node)) + Number(mentionedDefinitions.has(node))]));
+    const total = [...weights.values()].reduce((sum, weight) => sum + weight, 0);
+    const personalization = new Map(nodes.map((node) => [node, total ? weights.get(node) / total : 1 / count]));
+    let ranks = new Map(nodes.map((node) => [node, 1 / count]));
+    for (let iteration = 0; iteration < 100; iteration++) {
+      let dangling = 0;
+      for (const node of nodes) {
+        if (!this.outbound.get(node)) dangling += ranks.get(node);
       }
-      if (mentionedIdents) {
-        const fileTags = tags.filter((t) => t.rel_fname === node && t.kind === "def");
-        if (fileTags.some((t) => mentionedIdents.has(t.name))) {
-          score += personalize;
+      const base = 0.85 * dangling + 0.15;
+      const next = new Map(nodes.map((node) => [node, base * personalization.get(node)]));
+      for (const { definers, sources } of this.relations) {
+        let incoming = 0;
+        for (const [source, weight] of sources) {
+          incoming += 0.85 * ranks.get(source) * weight / this.outbound.get(source);
         }
-      }
-      if (score > 0) {
-        personalization[node] = score;
-      }
-    }
-    try {
-      const pagerankOptions = {
-        alpha: 0.85,
-        maxIterations: 100,
-        tolerance: 1e-6
-      };
-      if (Object.keys(personalization).length > 0) {
-        pagerankOptions.personalization = personalization;
-      }
-      const ranks = (0, import_pagerank.default)(graph, pagerankOptions);
-      const rankedDefinitions = [];
-      const definitions = tags.filter((t) => t.kind === "def");
-      for (const def of definitions) {
-        const nodeRank = ranks[def.rel_fname] || 0;
-        let edgeRank = nodeRank;
-        if (graph.hasNode(def.rel_fname)) {
-          graph.forEachOutboundEdge(def.rel_fname, (edge) => {
-            const weight = graph.getEdgeAttribute(edge, "weight");
-            const totalWeight = this.getTotalOutboundWeight(graph, def.rel_fname);
-            if (totalWeight > 0) {
-              edgeRank += nodeRank * (weight / totalWeight);
-            }
-          });
+        for (const target of definers) {
+          const self = sources.get(target);
+          const contribution = incoming - (self ? 0.85 * ranks.get(target) * self / this.outbound.get(target) : 0);
+          next.set(target, next.get(target) + contribution);
         }
-        rankedDefinitions.push({
-          rel_fname: def.rel_fname,
-          name: def.name,
-          rank: edgeRank,
-          line: def.line
-        });
       }
-      rankedDefinitions.sort((a, b) => b.rank - a.rank);
-      logger_default.info(`[PageRankCalculator] Calculated ranks for ${rankedDefinitions.length} definitions`);
-      return rankedDefinitions;
-    } catch (error) {
-      logger_default.error("[PageRankCalculator] Error calculating PageRank:", error);
-      return [];
+      let error = 0;
+      for (const node of nodes) error += Math.abs(next.get(node) - ranks.get(node));
+      ranks = next;
+      if (error < count * 1e-6) break;
+      if (iteration === 99) throw new Error("Repository map PageRank did not converge");
     }
-  }
-  getTotalOutboundWeight(graph, node) {
-    if (!graph.hasNode(node)) {
-      return 0;
-    }
-    let total = 0;
-    graph.forEachOutboundEdge(node, (edge) => {
-      total += graph.getEdgeAttribute(edge, "weight") || 1;
-    });
-    return total;
+    return this.definitions.map((tag) => ({
+      rel_fname: tag.rel_fname,
+      name: tag.name,
+      line: tag.line,
+      rank: ranks.get(tag.rel_fname) * (this.outbound.get(tag.rel_fname) ? 2 : 1)
+    })).sort((a, b) => b.rank - a.rank);
   }
 };
 
 // src/tree-renderer.ts
-var fs3 = __toESM(require("fs/promises"));
+var fs4 = __toESM(require("fs/promises"));
+var path6 = __toESM(require("path"));
 var TreeRenderer = class {
-  async render(rankedDefinitions, chatFiles, maxLines) {
+  async render(rankedDefinitions, chatFiles, maxLines, root = process.cwd()) {
     const filtered = rankedDefinitions.filter((def) => !chatFiles.has(def.rel_fname));
     const byFile = /* @__PURE__ */ new Map();
     for (const def of filtered) {
@@ -638,24 +576,26 @@ var TreeRenderer = class {
       fileDefs.push(def);
       byFile.set(def.rel_fname, fileDefs);
     }
+    const maximumRanks = /* @__PURE__ */ new Map();
+    for (const def of filtered) maximumRanks.set(def.rel_fname, Math.max(maximumRanks.get(def.rel_fname) ?? -Infinity, def.rank));
     const sortedFiles = Array.from(byFile.entries()).sort((a, b) => {
-      const maxRankA = Math.max(...a[1].map((d) => d.rank));
-      const maxRankB = Math.max(...b[1].map((d) => d.rank));
+      const maxRankA = maximumRanks.get(a[0]);
+      const maxRankB = maximumRanks.get(b[0]);
       return maxRankB - maxRankA;
     });
     const totalFiles = sortedFiles.length;
     if (!maxLines) {
-      return this.renderAllFiles(sortedFiles);
+      return this.renderAllFiles(sortedFiles, root);
     }
-    if (totalFiles > maxLines) {
+    if (totalFiles * 2 > maxLines) {
       return this.renderFileListOnly(sortedFiles, maxLines);
     }
     const headerLines = totalFiles;
     const availableLines = maxLines - headerLines;
     const linesPerFile = Math.max(1, Math.floor(availableLines / totalFiles));
-    return this.renderWithLineLimit(sortedFiles, linesPerFile);
+    return this.renderWithLineLimit(sortedFiles, linesPerFile, root);
   }
-  async renderAllFiles(sortedFiles) {
+  async renderAllFiles(sortedFiles, root) {
     let output = "";
     for (const [file, definitions] of sortedFiles) {
       output += `
@@ -663,7 +603,7 @@ ${file}:
 `;
       definitions.sort((a, b) => a.line - b.line);
       const lines = Array.from(new Set(definitions.map((d) => d.line)));
-      const treeLines = await this.renderFileTree(file, lines, Infinity);
+      const treeLines = await this.renderFileTree(path6.resolve(root, file), lines, Infinity);
       output += treeLines;
     }
     return output.trim();
@@ -680,7 +620,7 @@ ${file}:
     }
     return output.trim();
   }
-  async renderWithLineLimit(sortedFiles, linesPerFile) {
+  async renderWithLineLimit(sortedFiles, linesPerFile, root) {
     let output = "";
     for (const [file, definitions] of sortedFiles) {
       definitions.sort((a, b) => {
@@ -694,7 +634,7 @@ ${file}:
       const isTruncated = uniqueLines.length > linesPerFile;
       output += `${file}:
 `;
-      const treeLines = await this.renderFileTree(file, limitedLines, linesPerFile, isTruncated);
+      const treeLines = await this.renderFileTree(path6.resolve(root, file), limitedLines, linesPerFile, isTruncated);
       output += treeLines;
     }
     return output.trim();
@@ -704,7 +644,7 @@ ${file}:
       return "";
     }
     try {
-      const content = await fs3.readFile(filePath, "utf-8");
+      const content = await fs4.readFile(filePath, "utf-8");
       const fileLines = content.split("\n");
       let output = "";
       const maxContentLines = isTruncated ? maxLines - 1 : maxLines;
@@ -733,119 +673,102 @@ ${file}:
 
 // src/cache-manager.ts
 var import_node_sqlite = require("node:sqlite");
-var fs4 = __toESM(require("fs/promises"));
-var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs/promises"));
+var path7 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
-function getCacheDbPath() {
-  const platform3 = os2.platform();
-  const homeDir = os2.homedir();
-  let cacheDir;
-  if (platform3 === "darwin") {
-    cacheDir = path5.join(homeDir, "Library", "Caches", "aiderdesk", "tree-sitter");
-  } else if (platform3 === "win32") {
-    cacheDir = path5.join(process.env.APPDATA || path5.join(homeDir, "AppData", "Roaming"), "aiderdesk", "tree-sitter");
-  } else {
-    cacheDir = path5.join(homeDir, ".cache", "aiderdesk", "tree-sitter");
-  }
-  return path5.join(cacheDir, "cache.db");
-}
+var getCacheDbPath = () => {
+  const home = os2.homedir();
+  const directory = process.platform === "darwin" ? path7.join(home, "Library", "Caches") : process.platform === "win32" ? process.env.APPDATA || path7.join(home, "AppData", "Roaming") : path7.join(home, ".cache");
+  return path7.join(directory, "aiderdesk", "tree-sitter", "cache.db");
+};
 var CacheManager = class {
-  db = null;
-  dbPath;
-  constructor(dbPath) {
-    this.dbPath = dbPath || getCacheDbPath();
+  constructor(dbPath = getCacheDbPath()) {
+    this.dbPath = dbPath;
   }
+  db = null;
+  select;
+  insert;
   async initialize() {
     try {
-      await fs4.mkdir(path5.dirname(this.dbPath), { recursive: true });
+      await fs5.mkdir(path7.dirname(this.dbPath), { recursive: true });
       this.db = new import_node_sqlite.DatabaseSync(this.dbPath);
-      const createTableSQL = `
-        CREATE TABLE IF NOT EXISTS file_cache (
+      this.db.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA busy_timeout = 1000;");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS file_cache_v3 (
           file_path TEXT PRIMARY KEY,
-          mtime INTEGER NOT NULL,
-          tags TEXT NOT NULL,
-          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+          mtime REAL NOT NULL,
+          fingerprint TEXT NOT NULL,
+          tags TEXT NOT NULL
         )
-      `;
-      this.db.exec(createTableSQL);
-      logger_default.info(`[CacheManager] Cache database initialized at ${this.dbPath}`);
+      `);
+      this.select = this.db.prepare("SELECT mtime, fingerprint, tags FROM file_cache_v3 WHERE file_path = ?");
+      this.insert = this.db.prepare(`
+        INSERT INTO file_cache_v3 (file_path, mtime, fingerprint, tags) VALUES (?, ?, ?, ?)
+        ON CONFLICT(file_path) DO UPDATE SET mtime = excluded.mtime, fingerprint = excluded.fingerprint, tags = excluded.tags
+      `);
     } catch (error) {
-      logger_default.error("[CacheManager] Failed to initialize cache database:", error);
-      this.db = null;
+      logger_default.warn("[CacheManager] Persistent cache unavailable:", error);
+      this.close();
     }
   }
-  async getFileCache(filePath) {
-    if (!this.db) {
-      return null;
-    }
+  async getFileCache(file) {
     try {
-      const sql = "SELECT mtime, tags FROM file_cache WHERE file_path = ?";
-      const stmt = this.db.prepare(sql);
-      const result = stmt.get(filePath);
-      if (result) {
-        const tags = JSON.parse(result.tags);
-        return { tags, mtime: result.mtime };
-      }
-      return null;
+      const result = this.select?.get(file);
+      if (!result) return null;
+      const stored = JSON.parse(result.tags);
+      return {
+        ...result,
+        tags: stored.tags.map(([line, name, kind, count]) => ({
+          fname: file,
+          rel_fname: stored.relative,
+          line,
+          name,
+          kind,
+          count
+        }))
+      };
     } catch (error) {
-      logger_default.error(`[CacheManager] Failed to get cache for ${filePath}:`, error);
+      logger_default.warn(`[CacheManager] Failed to read ${file}:`, error);
       return null;
     }
   }
-  async setFileCache(filePath, mtime, tags) {
-    if (!this.db) {
-      return;
-    }
+  async setFileCache(file, mtime, tags, fingerprint = String(mtime)) {
     try {
-      const sql = `
-        INSERT INTO file_cache (file_path, mtime, tags, updated_at)
-        VALUES (?, ?, ?, CURRENT_TIMESTAMP)
-        ON CONFLICT(file_path) DO UPDATE SET
-          mtime = excluded.mtime,
-          tags = excluded.tags,
-          updated_at = CURRENT_TIMESTAMP
-      `;
-      const stmt = this.db.prepare(sql);
-      stmt.run(filePath, mtime, JSON.stringify(tags));
-      logger_default.debug(`[CacheManager] Cached ${tags.length} tags for ${filePath}`);
+      this.insert?.run(
+        file,
+        mtime,
+        fingerprint,
+        JSON.stringify({
+          relative: tags[0]?.rel_fname ?? file,
+          tags: tags.map((tag) => [tag.line, tag.name, tag.kind, tag.count])
+        })
+      );
     } catch (error) {
-      logger_default.error(`[CacheManager] Failed to set cache for ${filePath}:`, error);
+      logger_default.warn(`[CacheManager] Failed to cache ${file}:`, error);
     }
   }
-  async getFileMtime(filePath) {
+  async getFileMtime(file) {
     try {
-      const stats = await fs4.stat(filePath);
-      return stats.mtimeMs;
-    } catch (error) {
-      logger_default.error(`[CacheManager] Failed to get mtime for ${filePath}:`, error);
+      return (await fs5.stat(file)).mtimeMs;
+    } catch {
       return null;
     }
   }
   async clearCache() {
-    if (!this.db) {
-      return;
-    }
-    try {
-      const sql = "DELETE FROM file_cache";
-      this.db.exec(sql);
-      logger_default.info("[CacheManager] Cache cleared");
-    } catch (error) {
-      logger_default.error("[CacheManager] Failed to clear cache:", error);
-    }
+    this.db?.exec("DELETE FROM file_cache_v3");
   }
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      logger_default.info("[CacheManager] Cache database closed");
-    }
+    this.select = void 0;
+    this.insert = void 0;
+    this.db?.close();
+    this.db = null;
   }
 };
 
 // src/file-utils.ts
-var path6 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 var import_glob = require("glob");
+var import_minimatch = require("minimatch");
 var import_simple_git = require("simple-git");
 var DEFAULT_IGNORE_PATTERNS = [
   "node_modules/**",
@@ -865,170 +788,430 @@ var DEFAULT_IGNORE_PATTERNS = [
   "yarn.lock",
   "pnpm-lock.yaml"
 ];
-var isGitRepository = async (baseDir) => {
-  try {
-    const git = (0, import_simple_git.simpleGit)(baseDir);
-    await git.revparse(["--git-dir"]);
-    return true;
-  } catch {
-    return false;
-  }
-};
 var getAllFilesFromGit = async (baseDir) => {
   try {
-    const git = (0, import_simple_git.simpleGit)(baseDir);
-    const result = await git.raw(["ls-files", "-z"]);
-    const files = result.split("\0").filter(Boolean);
-    logger_default.debug(`Retrieved ${files.length} tracked files from Git`);
-    return files.map((file) => path6.resolve(baseDir, file));
-  } catch (gitError) {
-    logger_default.warn("Failed to get tracked files from Git, falling back to filesystem", gitError);
-    return [];
-  }
-};
-var getAllFilesFromFS = async (baseDir, ignore) => {
-  try {
-    const pattern = path6.join(baseDir, "**/*").replace(/\\/g, "/");
-    const files = await (0, import_glob.glob)(pattern, {
-      nodir: true,
-      absolute: true,
-      dot: false,
-      ignore
-    });
-    logger_default.debug(`Retrieved ${files.length} files from filesystem`);
-    return files;
+    const result = await (0, import_simple_git.simpleGit)(baseDir).raw(["ls-files", "-z"]);
+    return result.split(String.fromCharCode(0)).filter(Boolean).map((file) => path8.resolve(baseDir, file));
   } catch (error) {
-    logger_default.error("Failed to get files from filesystem:", error);
-    return [];
+    logger_default.debug("Git discovery unavailable, falling back to filesystem", error);
+    return null;
   }
 };
-var matchesPattern = (filePath, pattern) => {
-  const regexPattern = pattern.replace(/\*\*/g, "<<DOUBLE_STAR>>").replace(/\*/g, "[^/]*").replace(/<<DOUBLE_STAR>>/g, ".*").replace(/\?/g, "[^/]");
-  const regex = new RegExp(regexPattern);
-  return regex.test(filePath);
-};
-var filterByExcludePatterns = (files, excludePatterns, baseDir) => {
-  return files.filter((file) => {
-    const relative3 = path6.relative(baseDir, file).replace(/\\/g, "/");
-    return !excludePatterns.some((pattern) => matchesPattern(relative3, pattern));
-  });
-};
 var getAllFiles = async (baseDir, excludePatterns = []) => {
-  const allIgnorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...excludePatterns];
+  const ignore = [...DEFAULT_IGNORE_PATTERNS, ...excludePatterns];
+  const matchers = ignore.map((pattern) => ({
+    regex: new import_minimatch.Minimatch(pattern, { dot: true }).makeRe(),
+    basename: !pattern.includes("/")
+  }));
+  const gitFiles = await getAllFilesFromGit(baseDir);
+  if (gitFiles !== null) {
+    return gitFiles.filter((file) => {
+      const relative5 = path8.relative(baseDir, file).split(path8.sep).join("/");
+      const basename2 = path8.basename(file);
+      return !matchers.some((matcher) => matcher.regex && matcher.regex.test(matcher.basename ? basename2 : relative5));
+    });
+  }
   try {
-    if (await isGitRepository(baseDir)) {
-      const gitFiles = await getAllFilesFromGit(baseDir);
-      if (gitFiles.length > 0) {
-        return filterByExcludePatterns(gitFiles, excludePatterns, baseDir);
-      }
-    }
-    const fsFiles = await getAllFilesFromFS(baseDir, allIgnorePatterns);
-    return filterByExcludePatterns(fsFiles, excludePatterns, baseDir);
+    return await (0, import_glob.glob)("**/*", { cwd: baseDir, nodir: true, absolute: true, dot: false, ignore });
   } catch (error) {
-    logger_default.error("Failed to get files:", error);
+    logger_default.error("Failed to discover repository files:", error);
     return [];
   }
 };
 
 // src/tree-sitter-analyzer.ts
 var TreeSitterAnalyzer = class {
-  parser;
-  symbolExtractor;
-  graphBuilder;
-  pageRankCalculator;
-  treeRenderer;
+  parser = new TreeSitterParser();
+  symbolExtractor = new SymbolExtractor(this.parser);
+  treeRenderer = new TreeRenderer();
   cacheManager;
-  initialized = false;
-  constructor() {
-    this.parser = new TreeSitterParser();
-    this.cacheManager = new CacheManager();
-    this.symbolExtractor = new SymbolExtractor(this.parser);
+  initialization;
+  queue = Promise.resolve();
+  graph;
+  revision = -1;
+  outputs = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.cacheManager = new CacheManager(options.cachePath);
     this.symbolExtractor.setCacheManager(this.cacheManager);
-    this.graphBuilder = new GraphBuilder();
-    this.pageRankCalculator = new PageRankCalculator();
-    this.treeRenderer = new TreeRenderer();
   }
-  async initialize() {
-    if (this.initialized) {
-      return;
+  initialize() {
+    this.initialization ??= Promise.all([this.parser.initialize(), this.cacheManager.initialize()]).then(() => void 0);
+    return this.initialization;
+  }
+  getRepoMap(options) {
+    const result = this.queue.then(() => this.generateRepoMap(options));
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async generateRepoMap(options) {
+    options.signal?.throwIfAborted();
+    await this.initialize();
+    const root = path9.resolve(options.root);
+    const normalize = (files2 = /* @__PURE__ */ new Set()) => new Set([...files2].map((file) => path9.relative(root, path9.resolve(root, file)).replaceAll(path9.sep, "/")));
+    const mentionedFiles = normalize(options.mentionedFiles);
+    const chatFiles = normalize(options.chatFiles);
+    const mentionedIdents = options.mentionedIdents ?? /* @__PURE__ */ new Set();
+    const files = options.files?.length ? options.files.map((file) => path9.resolve(root, file)) : await getAllFiles(root, options.excludePatterns);
+    options.signal?.throwIfAborted();
+    const tags = await this.symbolExtractor.extractTags(files, root, options.signal, true);
+    if (!tags.length) return "";
+    if (this.revision !== this.symbolExtractor.revision) {
+      this.graph = new DependencyIndex(tags);
+      this.revision = this.symbolExtractor.revision;
+      this.outputs.clear();
     }
-    await this.parser.initialize();
-    await this.cacheManager.initialize();
-    this.initialized = true;
-    logger_default.info("[TreeSitterAnalyzer] Initialized");
+    if (options.prepareOnly) return "";
+    const key = JSON.stringify([[...mentionedFiles].sort(), [...mentionedIdents].sort(), [...chatFiles].sort(), options.maxLines]);
+    const cached = this.outputs.get(key);
+    if (cached !== void 0) return cached;
+    options.signal?.throwIfAborted();
+    const ranked = this.graph.rank(mentionedFiles, mentionedIdents);
+    options.signal?.throwIfAborted();
+    const output = await this.treeRenderer.render(ranked, chatFiles, options.maxLines, root);
+    options.signal?.throwIfAborted();
+    if (this.outputs.size >= 8) this.outputs.delete(this.outputs.keys().next().value);
+    this.outputs.set(key, output);
+    return output;
   }
-  async getRepoMap(options) {
-    if (!this.initialized) {
+  extractSymbols(filePaths, options) {
+    const result = this.queue.then(async () => {
       await this.initialize();
+      if (options?.useCache === false) this.symbolExtractor.setCacheManager(null);
+      try {
+        const tags = await this.symbolExtractor.extractTags(filePaths, options?.rootDir);
+        return tags.map((tag) => ({
+          name: tag.name,
+          kind: tag.kind,
+          line: tag.line,
+          file: tag.fname,
+          relativeFile: tag.rel_fname
+        }));
+      } finally {
+        this.symbolExtractor.setCacheManager(this.cacheManager);
+      }
+    });
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async parseFile(filePath) {
+    await this.initialize();
+    const { detectLanguage: detectLanguage2 } = await Promise.resolve().then(() => (init_language_detector(), language_detector_exports));
+    return {
+      tags: await this.parser.parseFile(filePath),
+      file: filePath,
+      language: detectLanguage2(filePath) || "unknown"
+    };
+  }
+  async dispose() {
+    await this.queue;
+    await this.parser.dispose();
+    this.cacheManager.close();
+    this.graph = void 0;
+    this.outputs.clear();
+  }
+};
+
+// src/graph-builder.ts
+var import_graphology = __toESM(require("graphology"));
+var GraphBuilder = class {
+  buildDependencyGraph(tags) {
+    const graph = new import_graphology.default({ type: "directed", allowSelfLoops: false, multi: true });
+    const defines = /* @__PURE__ */ new Map();
+    const references = /* @__PURE__ */ new Map();
+    const definitions = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      if (tag.kind === "def") {
+        if (!defines.has(tag.name)) {
+          defines.set(tag.name, /* @__PURE__ */ new Set());
+        }
+        defines.get(tag.name).add(tag.rel_fname);
+        const key = `${tag.rel_fname}:${tag.name}`;
+        if (!definitions.has(key)) {
+          definitions.set(key, []);
+        }
+        definitions.get(key).push(tag);
+      } else if (tag.kind === "ref") {
+        if (!references.has(tag.name)) {
+          references.set(tag.name, []);
+        }
+        references.get(tag.name).push(tag.rel_fname);
+      }
     }
-    const { root, files, excludePatterns = [], mentionedFiles = /* @__PURE__ */ new Set(), mentionedIdents = /* @__PURE__ */ new Set(), chatFiles = /* @__PURE__ */ new Set(), maxLines } = options;
-    try {
-      let filesToProcess;
-      if (files && files.length > 0) {
-        filesToProcess = files;
-      } else {
-        filesToProcess = await getAllFiles(root, excludePatterns);
+    const idents = new Set(Array.from(defines.keys()).filter((k) => references.has(k)));
+    for (const ident of Array.from(idents)) {
+      const definers = Array.from(defines.get(ident) || []);
+      const referencers = references.get(ident) || [];
+      let mul = 1;
+      if (this.isSnakeCase(ident) || this.isKebabCase(ident) || this.isCamelCase(ident)) {
+        mul *= 10;
+      }
+      if (ident.startsWith("_")) {
+        mul *= 0.1;
       }
-      logger_default.info(`[TreeSitterAnalyzer] Processing ${filesToProcess.length} files for repository map`);
-      const tags = await this.symbolExtractor.extractTags(filesToProcess, root);
-      if (tags.length === 0) {
-        return "";
+      if (definers.length > 5) {
+        mul *= 0.1;
+      }
+      const refCounts = /* @__PURE__ */ new Map();
+      for (const ref of referencers) {
+        refCounts.set(ref, (refCounts.get(ref) || 0) + 1);
+      }
+      for (const referencer of referencers) {
+        const numRefs = refCounts.get(referencer) || 1;
+        const weight = mul * Math.sqrt(numRefs);
+        for (const definer of definers) {
+          if (referencer !== definer) {
+            if (!graph.hasNode(referencer)) {
+              graph.addNode(referencer);
+            }
+            if (!graph.hasNode(definer)) {
+              graph.addNode(definer);
+            }
+            const edgeKey = `${referencer}->${definer}:${ident}`;
+            if (!graph.hasEdge(edgeKey)) {
+              graph.addEdgeWithKey(edgeKey, referencer, definer, { weight, ident });
+            }
+          }
+        }
       }
-      const { graph, defines: _defines, references: _references } = this.graphBuilder.buildDependencyGraph(tags);
-      const rankedDefinitions = this.pageRankCalculator.calculate(graph, tags, mentionedFiles, mentionedIdents);
-      const output = await this.treeRenderer.render(rankedDefinitions, chatFiles, maxLines);
-      logger_default.info(`[TreeSitterAnalyzer] Generated repository map with ${rankedDefinitions.length} definitions`);
-      return output;
-    } catch (error) {
-      logger_default.error("[TreeSitterAnalyzer] Error generating repository map:", error);
-      return "";
     }
+    logger_default.info(`[GraphBuilder] Built graph with ${graph.order} nodes and ${graph.size} edges`);
+    return { graph, defines, references };
   }
-  async extractSymbols(filePaths, options) {
-    if (!this.initialized) {
-      await this.initialize();
+  isSnakeCase(str) {
+    return /^[a-z][a-z0-9_]*$/.test(str) && str.includes("_");
+  }
+  isKebabCase(str) {
+    return /^[a-z][a-z0-9-]*$/.test(str) && str.includes("-");
+  }
+  isCamelCase(str) {
+    return /^[a-z][a-zA-Z0-9]*$/.test(str) && /[A-Z]/.test(str);
+  }
+};
+
+// src/pagerank.ts
+var import_pagerank = __toESM(require("graphology-metrics/centrality/pagerank"));
+var PageRankCalculator = class {
+  calculate(graph, tags, mentionedFiles, mentionedIdents) {
+    if (graph.order === 0) {
+      return [];
+    }
+    const personalization = {};
+    const nodes = graph.nodes();
+    const personalize = nodes.length > 0 ? 100 / nodes.length : 0;
+    for (const node of nodes) {
+      let score = 0;
+      if (mentionedFiles?.has(node)) {
+        score += personalize;
+      }
+      if (mentionedIdents) {
+        const fileTags = tags.filter((t) => t.rel_fname === node && t.kind === "def");
+        if (fileTags.some((t) => mentionedIdents.has(t.name))) {
+          score += personalize;
+        }
+      }
+      if (score > 0) {
+        personalization[node] = score;
+      }
     }
-    const useCache = options?.useCache !== false;
     try {
-      const originalCacheManager = useCache ? this.cacheManager : null;
-      if (!useCache) {
-        this.symbolExtractor.setCacheManager(null);
+      const pagerankOptions = {
+        alpha: 0.85,
+        maxIterations: 100,
+        tolerance: 1e-6
+      };
+      if (Object.keys(personalization).length > 0) {
+        pagerankOptions.personalization = personalization;
       }
-      const tags = await this.symbolExtractor.extractTags(filePaths, options?.rootDir);
-      if (!useCache) {
-        this.symbolExtractor.setCacheManager(this.cacheManager);
+      const ranks = (0, import_pagerank.default)(graph, pagerankOptions);
+      const rankedDefinitions = [];
+      const definitions = tags.filter((t) => t.kind === "def");
+      for (const def of definitions) {
+        const nodeRank = ranks[def.rel_fname] || 0;
+        let edgeRank = nodeRank;
+        if (graph.hasNode(def.rel_fname)) {
+          graph.forEachOutboundEdge(def.rel_fname, (edge) => {
+            const weight = graph.getEdgeAttribute(edge, "weight");
+            const totalWeight = this.getTotalOutboundWeight(graph, def.rel_fname);
+            if (totalWeight > 0) {
+              edgeRank += nodeRank * (weight / totalWeight);
+            }
+          });
+        }
+        rankedDefinitions.push({
+          rel_fname: def.rel_fname,
+          name: def.name,
+          rank: edgeRank,
+          line: def.line
+        });
       }
-      const symbols = tags.map((tag) => ({
-        name: tag.name,
-        kind: tag.kind,
-        line: tag.line,
-        file: tag.fname,
-        relativeFile: tag.rel_fname
-      }));
-      logger_default.info(`[TreeSitterAnalyzer] Extracted ${symbols.length} symbols from ${filePaths.length} files`);
-      return symbols;
+      rankedDefinitions.sort((a, b) => b.rank - a.rank);
+      logger_default.info(`[PageRankCalculator] Calculated ranks for ${rankedDefinitions.length} definitions`);
+      return rankedDefinitions;
     } catch (error) {
-      logger_default.error("[TreeSitterAnalyzer] Error extracting symbols:", error);
+      logger_default.error("[PageRankCalculator] Error calculating PageRank:", error);
       return [];
     }
   }
-  async parseFile(filePath) {
-    if (!this.initialized) {
-      await this.initialize();
+  getTotalOutboundWeight(graph, node) {
+    if (!graph.hasNode(node)) {
+      return 0;
     }
-    const { detectLanguage: detectLanguage2 } = await Promise.resolve().then(() => (init_language_detector(), language_detector_exports));
-    const language = detectLanguage2(filePath) || "unknown";
-    const tags = await this.parser.parseFile(filePath);
-    return {
-      tags,
-      file: filePath,
-      language
-    };
+    let total = 0;
+    graph.forEachOutboundEdge(node, (edge) => {
+      total += graph.getEdgeAttribute(edge, "weight") || 1;
+    });
+    return total;
   }
 };
 
 // src/index.ts
 init_language_detector();
+
+// src/repo-map-service.ts
+var path10 = __toESM(require("path"));
+var import_worker_threads = require("worker_threads");
+var RepoMapService = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  worker;
+  active;
+  jobs = /* @__PURE__ */ new Map();
+  queue = [];
+  sequence = 0;
+  idleTimer;
+  getRepoMap(options) {
+    if (options.signal?.aborted) return Promise.reject(new Error("Repository map cancelled", { cause: options.signal.reason }));
+    const root = path10.resolve(options.root);
+    const { signal, ...serializable } = options;
+    const request = { ...serializable, root };
+    const key = JSON.stringify([
+      root,
+      request.files,
+      request.excludePatterns,
+      request.maxLines,
+      request.prepareOnly,
+      [...request.mentionedFiles ?? []].sort(),
+      [...request.mentionedIdents ?? []].sort(),
+      [...request.chatFiles ?? []].sort()
+    ]);
+    let job = this.jobs.get(key);
+    if (!job) {
+      if (this.jobs.size >= 64) return Promise.reject(new Error("Repository map queue is full"));
+      job = {
+        id: ++this.sequence,
+        key,
+        options: request,
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      this.jobs.set(key, job);
+      this.queue.push(job);
+    }
+    const pending = job;
+    return new Promise((resolve5, reject) => {
+      const abort = () => {
+        subscriber.cleanup();
+        pending.subscribers.delete(subscriber);
+        reject(new Error("Repository map cancelled", { cause: signal?.reason }));
+        if (!pending.subscribers.size) {
+          this.jobs.delete(pending.key);
+          this.queue = this.queue.filter((queued) => queued !== pending);
+          if (this.active === pending) {
+            this.stopWorker();
+            this.active = void 0;
+          }
+          this.schedule();
+        }
+      };
+      const subscriber = {
+        resolve: resolve5,
+        reject,
+        cleanup: () => signal?.removeEventListener("abort", abort)
+      };
+      pending.subscribers.add(subscriber);
+      signal?.addEventListener("abort", abort, { once: true });
+      this.schedule();
+    });
+  }
+  schedule() {
+    if (this.active) return;
+    const next = this.queue.shift();
+    if (!next) return;
+    clearTimeout(this.idleTimer);
+    this.active = next;
+    try {
+      if (!this.worker) {
+        const worker = new import_worker_threads.Worker(path10.join(__dirname, "repo-map-worker.js"), {
+          workerData: this.options,
+          resourceLimits: { maxOldGenerationSizeMb: 512 }
+        });
+        this.worker = worker;
+        worker.on("message", (response) => {
+          if (this.worker !== worker || this.active?.id !== response.id) return;
+          this.finish(response);
+        });
+        worker.on("error", (error) => {
+          if (this.worker !== worker) return;
+          this.stopWorker();
+          if (this.active) this.finish({ id: this.active.id, error: error.message });
+        });
+        worker.on("exit", (code) => {
+          if (this.worker !== worker) return;
+          this.worker = void 0;
+          if (this.active)
+            this.finish({
+              id: this.active.id,
+              error: `Repository map worker exited (${code})`
+            });
+        });
+      }
+      this.worker.ref();
+      this.worker.postMessage({
+        id: next.id,
+        options: next.options
+      });
+    } catch (error) {
+      this.stopWorker();
+      this.finish({ id: next.id, error: String(error) });
+    }
+  }
+  finish(response) {
+    const job = this.active;
+    if (!job) return;
+    this.jobs.delete(job.key);
+    this.active = void 0;
+    for (const subscriber of job.subscribers) {
+      subscriber.cleanup();
+      if (response.error !== void 0) subscriber.reject(new Error(response.error));
+      else subscriber.resolve(response.output ?? "");
+    }
+    this.worker?.unref();
+    this.idleTimer = setTimeout(() => this.stopWorker(), 5 * 60 * 1e3);
+    this.idleTimer.unref();
+    this.schedule();
+  }
+  stopWorker() {
+    const worker = this.worker;
+    this.worker = void 0;
+    void worker?.terminate();
+  }
+  dispose() {
+    clearTimeout(this.idleTimer);
+    this.stopWorker();
+    for (const job of this.jobs.values()) {
+      for (const subscriber of job.subscribers) {
+        subscriber.cleanup();
+        subscriber.reject(new Error("Repository map service disposed"));
+      }
+    }
+    this.jobs.clear();
+    this.queue = [];
+    this.active = void 0;
+  }
+};
+
+// src/index.ts
+var repoMapService = new RepoMapService();
 var defaultAnalyzer = null;
 async function getAnalyzer() {
   if (!defaultAnalyzer) {
@@ -1042,14 +1225,14 @@ async function extractSymbols(filePaths, options) {
   return analyzer.extractSymbols(filePaths, options);
 }
 async function getRepoMap(root, options) {
-  const analyzer = await getAnalyzer();
-  return analyzer.getRepoMap({ ...options, root });
+  return repoMapService.getRepoMap({ ...options, root });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CacheManager,
   GraphBuilder,
   PageRankCalculator,
+  RepoMapService,
   SymbolExtractor,
   TreeRenderer,
   TreeSitterAnalyzer,