@aiderdesk/tree-sitter-utils 0.1.0

package/dist/index.js

@@ -0,0 +1,1070 @@
+"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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CacheManager: () => CacheManager,
+  GraphBuilder: () => GraphBuilder,
+  PageRankCalculator: () => PageRankCalculator,
+  SymbolExtractor: () => SymbolExtractor,
+  TreeRenderer: () => TreeRenderer,
+  TreeSitterAnalyzer: () => TreeSitterAnalyzer,
+  TreeSitterParser: () => TreeSitterParser,
+  detectLanguage: () => detectLanguage,
+  downloadWasmForLanguage: () => downloadWasmForLanguage,
+  extractSymbols: () => extractSymbols,
+  getAllFiles: () => getAllFiles,
+  getLanguageWasmConfig: () => getLanguageWasmConfig,
+  getLogger: () => getLogger,
+  getRepoMap: () => getRepoMap,
+  getSupportedExtensions: () => getSupportedExtensions,
+  getSupportedLanguages: () => getSupportedLanguages,
+  getSupportedLanguagesForWasm: () => getSupportedLanguagesForWasm,
+  isLanguageSupported: () => isLanguageSupported,
+  setLogger: () => setLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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;
+function setLogger(logger) {
+  currentLogger = logger;
+}
+function getLogger() {
+  return currentLogger;
+}
+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/tree-sitter-c_sharp.wasm",
+    file: "tree-sitter-c_sharp.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 platform3 = os.platform();
+  const homeDir = os.homedir();
+  if (platform3 === "darwin") {
+    return path2.join(homeDir, "Library", "Caches", "aiderdesk", "tree-sitter");
+  } else if (platform3 === "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;
+  }
+}
+function getLanguageWasmConfig(language) {
+  return LANGUAGE_WASM_MAP[language] || null;
+}
+function getSupportedLanguagesForWasm() {
+  return Object.keys(LANGUAGE_WASM_MAP);
+}
+
+// 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 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);
+          }
+        }
+      } 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;
+    }
+  }
+  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;
+    }
+  }
+  async parseFile(filePath, rootDir) {
+    if (!this.initialized || !this.parser) {
+      await this.initialize();
+    }
+    if (!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 [];
+    }
+    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) {
+        for (const capture of match.captures) {
+          if (!capture.name.startsWith("name.")) {
+            continue;
+          }
+          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;
+  }
+  determineKind(captureName) {
+    if (captureName.includes("definition")) {
+      return "def";
+    }
+    return "ref";
+  }
+};
+
+// src/symbol-extractor.ts
+init_language_detector();
+var SymbolExtractor = class {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  cacheManager = null;
+  setCacheManager(cacheManager) {
+    this.cacheManager = cacheManager;
+  }
+  async extractTags(files, rootDir) {
+    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) => {
+          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);
+                return tags;
+              }
+            }
+            return await this.parser.parseFile(file, rootDir);
+          } catch (error) {
+            logger_default.error(`[SymbolExtractor] Error processing ${file}:`, error);
+            return [];
+          }
+        })
+      );
+      allTags.push(...batchTags.flat());
+    }
+    logger_default.info(`[SymbolExtractor] Extracted ${allTags.length} tags total`);
+    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/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 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 });
+            }
+          }
+        }
+      }
+    }
+    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;
+      }
+      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;
+      }
+    }
+    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);
+            }
+          });
+        }
+        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 [];
+    }
+  }
+  getTotalOutboundWeight(graph, node) {
+    if (!graph.hasNode(node)) {
+      return 0;
+    }
+    let total = 0;
+    graph.forEachOutboundEdge(node, (edge) => {
+      total += graph.getEdgeAttribute(edge, "weight") || 1;
+    });
+    return total;
+  }
+};
+
+// src/tree-renderer.ts
+var fs3 = __toESM(require("fs/promises"));
+var TreeRenderer = class {
+  async render(rankedDefinitions, chatFiles, maxLines) {
+    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 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));
+      return maxRankB - maxRankA;
+    });
+    const totalFiles = sortedFiles.length;
+    if (!maxLines) {
+      return this.renderAllFiles(sortedFiles);
+    }
+    if (totalFiles > 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);
+  }
+  async renderAllFiles(sortedFiles) {
+    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(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) {
+    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(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 fs3.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 fs4 = __toESM(require("fs/promises"));
+var path5 = __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 CacheManager = class {
+  db = null;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath || getCacheDbPath();
+  }
+  async initialize() {
+    try {
+      await fs4.mkdir(path5.dirname(this.dbPath), { recursive: true });
+      this.db = new import_node_sqlite.DatabaseSync(this.dbPath);
+      const createTableSQL = `
+        CREATE TABLE IF NOT EXISTS file_cache (
+          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
+        )
+      `;
+      this.db.exec(createTableSQL);
+      logger_default.info(`[CacheManager] Cache database initialized at ${this.dbPath}`);
+    } catch (error) {
+      logger_default.error("[CacheManager] Failed to initialize cache database:", error);
+      this.db = null;
+    }
+  }
+  async getFileCache(filePath) {
+    if (!this.db) {
+      return null;
+    }
+    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;
+    } catch (error) {
+      logger_default.error(`[CacheManager] Failed to get cache for ${filePath}:`, error);
+      return null;
+    }
+  }
+  async setFileCache(filePath, mtime, tags) {
+    if (!this.db) {
+      return;
+    }
+    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}`);
+    } catch (error) {
+      logger_default.error(`[CacheManager] Failed to set cache for ${filePath}:`, error);
+    }
+  }
+  async getFileMtime(filePath) {
+    try {
+      const stats = await fs4.stat(filePath);
+      return stats.mtimeMs;
+    } catch (error) {
+      logger_default.error(`[CacheManager] Failed to get mtime for ${filePath}:`, error);
+      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);
+    }
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      logger_default.info("[CacheManager] Cache database closed");
+    }
+  }
+};
+
+// src/file-utils.ts
+var path6 = __toESM(require("path"));
+var import_glob = require("glob");
+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 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;
+  } catch (error) {
+    logger_default.error("Failed to get files from filesystem:", error);
+    return [];
+  }
+};
+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];
+  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);
+  } catch (error) {
+    logger_default.error("Failed to get files:", error);
+    return [];
+  }
+};
+
+// src/tree-sitter-analyzer.ts
+var TreeSitterAnalyzer = class {
+  parser;
+  symbolExtractor;
+  graphBuilder;
+  pageRankCalculator;
+  treeRenderer;
+  cacheManager;
+  initialized = false;
+  constructor() {
+    this.parser = new TreeSitterParser();
+    this.cacheManager = new CacheManager();
+    this.symbolExtractor = new SymbolExtractor(this.parser);
+    this.symbolExtractor.setCacheManager(this.cacheManager);
+    this.graphBuilder = new GraphBuilder();
+    this.pageRankCalculator = new PageRankCalculator();
+    this.treeRenderer = new TreeRenderer();
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.parser.initialize();
+    await this.cacheManager.initialize();
+    this.initialized = true;
+    logger_default.info("[TreeSitterAnalyzer] Initialized");
+  }
+  async getRepoMap(options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    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);
+      }
+      logger_default.info(`[TreeSitterAnalyzer] Processing ${filesToProcess.length} files for repository map`);
+      const tags = await this.symbolExtractor.extractTags(filesToProcess, root);
+      if (tags.length === 0) {
+        return "";
+      }
+      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 "";
+    }
+  }
+  async extractSymbols(filePaths, options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const useCache = options?.useCache !== false;
+    try {
+      const originalCacheManager = useCache ? this.cacheManager : null;
+      if (!useCache) {
+        this.symbolExtractor.setCacheManager(null);
+      }
+      const tags = await this.symbolExtractor.extractTags(filePaths, options?.rootDir);
+      if (!useCache) {
+        this.symbolExtractor.setCacheManager(this.cacheManager);
+      }
+      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;
+    } catch (error) {
+      logger_default.error("[TreeSitterAnalyzer] Error extracting symbols:", error);
+      return [];
+    }
+  }
+  async parseFile(filePath) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    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
+    };
+  }
+};
+
+// src/index.ts
+init_language_detector();
+var defaultAnalyzer = null;
+async function getAnalyzer() {
+  if (!defaultAnalyzer) {
+    defaultAnalyzer = new TreeSitterAnalyzer();
+    await defaultAnalyzer.initialize();
+  }
+  return defaultAnalyzer;
+}
+async function extractSymbols(filePaths, options) {
+  const analyzer = await getAnalyzer();
+  return analyzer.extractSymbols(filePaths, options);
+}
+async function getRepoMap(root, options) {
+  const analyzer = await getAnalyzer();
+  return analyzer.getRepoMap({ ...options, root });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager,
+  GraphBuilder,
+  PageRankCalculator,
+  SymbolExtractor,
+  TreeRenderer,
+  TreeSitterAnalyzer,
+  TreeSitterParser,
+  detectLanguage,
+  downloadWasmForLanguage,
+  extractSymbols,
+  getAllFiles,
+  getLanguageWasmConfig,
+  getLogger,
+  getRepoMap,
+  getSupportedExtensions,
+  getSupportedLanguages,
+  getSupportedLanguagesForWasm,
+  isLanguageSupported,
+  setLogger
+});
+//# sourceMappingURL=index.js.map