@aiderdesk/tree-sitter-utils 0.1.0 → 0.2.0

package/dist/repo-map-worker.js

@@ -0,0 +1,907 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/language-detector.ts
+var language_detector_exports = {};
+__export(language_detector_exports, {
+  detectLanguage: () => detectLanguage,
+  getSupportedExtensions: () => getSupportedExtensions,
+  getSupportedLanguages: () => getSupportedLanguages,
+  isLanguageSupported: () => isLanguageSupported
+});
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return LANGUAGE_MAP[ext] || null;
+}
+function isLanguageSupported(filePath) {
+  return detectLanguage(filePath) !== null;
+}
+function getSupportedExtensions() {
+  return Object.keys(LANGUAGE_MAP);
+}
+function getSupportedLanguages() {
+  return [...new Set(Object.values(LANGUAGE_MAP))];
+}
+var path, LANGUAGE_MAP;
+var init_language_detector = __esm({
+  "src/language-detector.ts"() {
+    "use strict";
+    path = __toESM(require("path"));
+    LANGUAGE_MAP = {
+      ".py": "python",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".java": "java",
+      ".go": "go",
+      ".rs": "rust",
+      ".c": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".h": "c",
+      ".hpp": "cpp",
+      ".hxx": "cpp",
+      ".cs": "c_sharp",
+      ".dart": "dart",
+      ".hs": "haskell",
+      ".lhs": "haskell",
+      ".jl": "julia",
+      ".ml": "ocaml",
+      ".mli": "ocaml_interface",
+      ".php": "php",
+      ".rb": "ruby",
+      ".rake": "ruby",
+      ".gemspec": "ruby",
+      ".scala": "scala",
+      ".sc": "scala"
+    };
+  }
+});
+
+// src/repo-map-worker.ts
+var import_worker_threads = require("worker_threads");
+
+// 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"));
+var import_web_tree_sitter = require("web-tree-sitter");
+init_language_detector();
+
+// src/wasm-downloader.ts
+var fs = __toESM(require("fs/promises"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+
+// src/logger.ts
+var defaultLogger = {
+  info: (message, ...args) => console.log(`[TreeSitterUtils] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[TreeSitterUtils] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[TreeSitterUtils] ${message}`, ...args),
+  debug: (message, ...args) => {
+    if (process.env.DEBUG_TREE_SITTER) {
+      console.debug(`[TreeSitterUtils] ${message}`, ...args);
+    }
+  }
+};
+var currentLogger = defaultLogger;
+var logger_default = currentLogger;
+
+// src/wasm-downloader.ts
+var LANGUAGE_WASM_MAP = {
+  python: {
+    url: "https://unpkg.com/tree-sitter-python/tree-sitter-python.wasm",
+    file: "tree-sitter-python.wasm"
+  },
+  javascript: {
+    url: "https://unpkg.com/tree-sitter-javascript/tree-sitter-javascript.wasm",
+    file: "tree-sitter-javascript.wasm"
+  },
+  typescript: {
+    url: "https://unpkg.com/tree-sitter-typescript/tree-sitter-typescript.wasm",
+    file: "tree-sitter-typescript.wasm"
+  },
+  tsx: {
+    url: "https://unpkg.com/tree-sitter-typescript/tree-sitter-tsx.wasm",
+    file: "tree-sitter-tsx.wasm"
+  },
+  java: {
+    url: "https://unpkg.com/tree-sitter-java/tree-sitter-java.wasm",
+    file: "tree-sitter-java.wasm"
+  },
+  go: {
+    url: "https://unpkg.com/tree-sitter-go/tree-sitter-go.wasm",
+    file: "tree-sitter-go.wasm"
+  },
+  rust: {
+    url: "https://unpkg.com/tree-sitter-rust/tree-sitter-rust.wasm",
+    file: "tree-sitter-rust.wasm"
+  },
+  c: {
+    url: "https://unpkg.com/tree-sitter-c/tree-sitter-c.wasm",
+    file: "tree-sitter-c.wasm"
+  },
+  cpp: {
+    url: "https://unpkg.com/tree-sitter-cpp/tree-sitter-cpp.wasm",
+    file: "tree-sitter-cpp.wasm"
+  },
+  ruby: {
+    url: "https://unpkg.com/tree-sitter-ruby/tree-sitter-ruby.wasm",
+    file: "tree-sitter-ruby.wasm"
+  },
+  php: {
+    url: "https://unpkg.com/tree-sitter-php/tree-sitter-php.wasm",
+    file: "tree-sitter-php.wasm"
+  },
+  scala: {
+    url: "https://unpkg.com/tree-sitter-scala/tree-sitter-scala.wasm",
+    file: "tree-sitter-scala.wasm"
+  },
+  dart: {
+    url: "https://unpkg.com/tree-sitter-dart/tree-sitter-dart.wasm",
+    file: "tree-sitter-dart.wasm"
+  },
+  ocaml: {
+    url: "https://unpkg.com/tree-sitter-ocaml/tree-sitter-ocaml.wasm",
+    file: "tree-sitter-ocaml.wasm"
+  },
+  ocaml_interface: {
+    url: "https://unpkg.com/tree-sitter-ocaml/tree-sitter-ocaml_interface.wasm",
+    file: "tree-sitter-ocaml_interface.wasm"
+  },
+  c_sharp: {
+    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",
+    file: "tree-sitter-haskell.wasm"
+  },
+  julia: {
+    url: "https://unpkg.com/tree-sitter-julia/tree-sitter-julia.wasm",
+    file: "tree-sitter-julia.wasm"
+  }
+};
+function getCacheDir() {
+  const platform2 = os.platform();
+  const homeDir = os.homedir();
+  if (platform2 === "darwin") {
+    return path2.join(homeDir, "Library", "Caches", "aiderdesk", "tree-sitter");
+  } 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");
+  }
+}
+async function downloadWasmForLanguage(language) {
+  const config = LANGUAGE_WASM_MAP[language];
+  if (!config) {
+    logger_default.warn(`No WASM configuration for language: ${language}`);
+    return null;
+  }
+  const cacheDir = getCacheDir();
+  const wasmPath = path2.join(cacheDir, "wasm", config.file);
+  try {
+    try {
+      const buffer2 = await fs.readFile(wasmPath);
+      logger_default.debug(`Loaded WASM for ${language} from cache: ${wasmPath}`);
+      return buffer2;
+    } catch {
+    }
+    logger_default.info(`Downloading WASM for ${language} from ${config.url}`);
+    const response = await fetch(config.url, { redirect: "follow" });
+    if (!response.ok) {
+      throw new Error(`Failed to download ${language} WASM: ${response.status} ${response.statusText}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    await fs.mkdir(path2.dirname(wasmPath), { recursive: true });
+    await fs.writeFile(wasmPath, buffer);
+    logger_default.info(`Downloaded and cached WASM for ${language} (${Math.round(buffer.byteLength / 1024)} KB)`);
+    return buffer;
+  } catch (error) {
+    logger_default.error(`Failed to download WASM for ${language}:`, error);
+    return null;
+  }
+}
+
+// src/constants.ts
+var path3 = __toESM(require("path"));
+var import_url = require("url");
+var import_meta = {};
+var getDirname = () => {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  return path3.dirname((0, import_url.fileURLToPath)(import_meta.url));
+};
+var dirName = getDirname();
+var RESOURCES_DIR = path3.join(dirName, "..", "resources");
+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 {
+  parser = null;
+  languages = /* @__PURE__ */ new Map();
+  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);
+          }
+        }
+        return { language, query };
+      })();
+      this.languages.set(name, pending);
+      void pending.catch(() => this.languages.delete(name));
+    }
+    return pending;
+  }
+  parseFile(filePath, rootDir, compactReferences = false) {
+    const result = this.queue.then(() => this.parse(filePath, rootDir, compactReferences));
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async parse(filePath, rootDir, compactReferences = false) {
+    await this.initialize();
+    const name = detectLanguage(filePath);
+    if (!name || !this.parser) {
+      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 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.")) {
+            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);
+          }
+        }
+      }
+      return tags;
+    } finally {
+      tree.delete();
+    }
+  }
+  async dispose() {
+    await this.queue;
+    for (const pending of this.languages.values()) {
+      try {
+        const { query } = await pending;
+        query.delete();
+      } catch {
+      }
+    }
+    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, signal, compactReferences = false) {
+    const allTags = [];
+    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 {
+            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);
+            }
+            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 [];
+          }
+        })
+      );
+      for (const tags of results) {
+        for (const tag of tags) allTags.push(tag);
+      }
+    }
+    signal?.throwIfAborted();
+    return allTags;
+  }
+  filterDefinitions(tags) {
+    return tags.filter((tag) => tag.kind === "def");
+  }
+  filterReferences(tags) {
+    return tags.filter((tag) => tag.kind === "ref");
+  }
+  groupTagsByFile(tags) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const tag of tags) {
+      const fileTags = grouped.get(tag.rel_fname) || [];
+      fileTags.push(tag);
+      grouped.set(tag.rel_fname, fileTags);
+    }
+    return grouped;
+  }
+};
+
+// 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") {
+        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));
+      }
+    }
+    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 });
+    }
+  }
+  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);
+      }
+      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);
+        }
+        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);
+        }
+      }
+      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");
+    }
+    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 fs4 = __toESM(require("fs/promises"));
+var path6 = __toESM(require("path"));
+var TreeRenderer = class {
+  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) {
+      const fileDefs = byFile.get(def.rel_fname) || [];
+      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 = maximumRanks.get(a[0]);
+      const maxRankB = maximumRanks.get(b[0]);
+      return maxRankB - maxRankA;
+    });
+    const totalFiles = sortedFiles.length;
+    if (!maxLines) {
+      return this.renderAllFiles(sortedFiles, root);
+    }
+    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, root);
+  }
+  async renderAllFiles(sortedFiles, root) {
+    let output = "";
+    for (const [file, definitions] of sortedFiles) {
+      output += `
+${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(path6.resolve(root, file), lines, Infinity);
+      output += treeLines;
+    }
+    return output.trim();
+  }
+  renderFileListOnly(sortedFiles, maxLines) {
+    let output = "";
+    const filesToShow = sortedFiles.slice(0, maxLines - 1);
+    for (const [file] of filesToShow) {
+      output += `${file}
+`;
+    }
+    if (sortedFiles.length > filesToShow.length) {
+      output += "...\n";
+    }
+    return output.trim();
+  }
+  async renderWithLineLimit(sortedFiles, linesPerFile, root) {
+    let output = "";
+    for (const [file, definitions] of sortedFiles) {
+      definitions.sort((a, b) => {
+        if (a.rank !== b.rank) {
+          return b.rank - a.rank;
+        }
+        return a.line - b.line;
+      });
+      const uniqueLines = Array.from(new Set(definitions.map((d) => d.line)));
+      const limitedLines = uniqueLines.slice(0, linesPerFile);
+      const isTruncated = uniqueLines.length > linesPerFile;
+      output += `${file}:
+`;
+      const treeLines = await this.renderFileTree(path6.resolve(root, file), limitedLines, linesPerFile, isTruncated);
+      output += treeLines;
+    }
+    return output.trim();
+  }
+  async renderFileTree(filePath, lines, maxLines, isTruncated = false) {
+    if (lines.length === 0) {
+      return "";
+    }
+    try {
+      const content = await fs4.readFile(filePath, "utf-8");
+      const fileLines = content.split("\n");
+      let output = "";
+      const maxContentLines = isTruncated ? maxLines - 1 : maxLines;
+      const linesToRender = lines.slice(0, maxContentLines);
+      for (let i = 0; i < linesToRender.length; i++) {
+        const lineNum = linesToRender[i];
+        const lineContent = fileLines[lineNum]?.trim() || "";
+        if (lineContent) {
+          const truncated = lineContent.length > 100 ? lineContent.substring(0, 97) + "..." : lineContent;
+          const isLast = i === linesToRender.length - 1 && !isTruncated;
+          const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          output += `${prefix}${truncated}
+`;
+        }
+      }
+      if (isTruncated) {
+        output += "\u2514\u2500\u2500 ...\n";
+      }
+      return output;
+    } catch (error) {
+      logger_default.error(`[TreeRenderer] Error reading file ${filePath}:`, error);
+      return "";
+    }
+  }
+};
+
+// src/cache-manager.ts
+var import_node_sqlite = require("node:sqlite");
+var fs5 = __toESM(require("fs/promises"));
+var path7 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+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 {
+  constructor(dbPath = getCacheDbPath()) {
+    this.dbPath = dbPath;
+  }
+  db = null;
+  select;
+  insert;
+  async initialize() {
+    try {
+      await fs5.mkdir(path7.dirname(this.dbPath), { recursive: true });
+      this.db = new import_node_sqlite.DatabaseSync(this.dbPath);
+      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 REAL NOT NULL,
+          fingerprint TEXT NOT NULL,
+          tags TEXT NOT NULL
+        )
+      `);
+      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.warn("[CacheManager] Persistent cache unavailable:", error);
+      this.close();
+    }
+  }
+  async getFileCache(file) {
+    try {
+      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.warn(`[CacheManager] Failed to read ${file}:`, error);
+      return null;
+    }
+  }
+  async setFileCache(file, mtime, tags, fingerprint = String(mtime)) {
+    try {
+      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.warn(`[CacheManager] Failed to cache ${file}:`, error);
+    }
+  }
+  async getFileMtime(file) {
+    try {
+      return (await fs5.stat(file)).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+  async clearCache() {
+    this.db?.exec("DELETE FROM file_cache_v3");
+  }
+  close() {
+    this.select = void 0;
+    this.insert = void 0;
+    this.db?.close();
+    this.db = null;
+  }
+};
+
+// src/file-utils.ts
+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/**",
+  ".git/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  "out/**",
+  "coverage/**",
+  "*.min.js",
+  "*.min.css",
+  ".DS_Store",
+  "Thumbs.db",
+  "*.log",
+  "*.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+];
+var getAllFilesFromGit = async (baseDir) => {
+  try {
+    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.debug("Git discovery unavailable, falling back to filesystem", error);
+    return null;
+  }
+};
+var getAllFiles = async (baseDir, 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 {
+    return await (0, import_glob.glob)("**/*", { cwd: baseDir, nodir: true, absolute: true, dot: false, ignore });
+  } catch (error) {
+    logger_default.error("Failed to discover repository files:", error);
+    return [];
+  }
+};
+
+// src/tree-sitter-analyzer.ts
+var TreeSitterAnalyzer = class {
+  parser = new TreeSitterParser();
+  symbolExtractor = new SymbolExtractor(this.parser);
+  treeRenderer = new TreeRenderer();
+  cacheManager;
+  initialization;
+  queue = Promise.resolve();
+  graph;
+  revision = -1;
+  outputs = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.cacheManager = new CacheManager(options.cachePath);
+    this.symbolExtractor.setCacheManager(this.cacheManager);
+  }
+  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();
+    }
+    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;
+  }
+  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/repo-map-worker.ts
+var analyzers = /* @__PURE__ */ new Map();
+var configuration = import_worker_threads.workerData;
+import_worker_threads.parentPort.on("message", async (request) => {
+  try {
+    const root = request.options.root;
+    let analyzer = analyzers.get(root);
+    if (!analyzer) {
+      if (analyzers.size >= 2) {
+        const oldest = analyzers.keys().next().value;
+        await analyzers.get(oldest).dispose();
+        analyzers.delete(oldest);
+      }
+      analyzer = new TreeSitterAnalyzer(configuration);
+    }
+    analyzers.delete(root);
+    analyzers.set(root, analyzer);
+    const output = await analyzer.getRepoMap(request.options);
+    import_worker_threads.parentPort.postMessage({
+      id: request.id,
+      output
+    });
+  } catch (error) {
+    import_worker_threads.parentPort.postMessage({
+      id: request.id,
+      error: String(error)
+    });
+  }
+});
+//# sourceMappingURL=repo-map-worker.js.map