remem-mcp 0.6.2 → 0.6.4

package/dist/chunk-FA324IBN.js

@@ -0,0 +1,903 @@
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-XK4Y53J2.js";
+
+// src/utils/ulid.ts
+import { ulid } from "ulid";
+function generateId() {
+  return ulid();
+}
+var init_ulid = __esm({
+  "src/utils/ulid.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/codegraph/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
+  detectLanguage: () => detectLanguage,
+  findCallees: () => findCallees,
+  findCallers: () => findCallers,
+  impactAnalysis: () => impactAnalysis,
+  indexDirectory: () => indexDirectory,
+  indexFile: () => indexFile,
+  listSymbols: () => listSymbols,
+  parseFile: () => parseFile,
+  searchSymbols: () => searchSymbols
+});
+import { createHash } from "crypto";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { extname, join, relative, sep } from "path";
+async function getPack() {
+  if (!_pack) {
+    const mod = await import("@kreuzberg/tree-sitter-language-pack");
+    _pack = mod.default ?? mod;
+  }
+  return _pack;
+}
+function detectLanguage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return EXTENSION_MAP[ext] ?? null;
+}
+async function parseFile(filePath, repoPath) {
+  const language = detectLanguage(filePath);
+  if (!language) return null;
+  const pack = await getPack();
+  if (!pack.hasLanguage(language)) return null;
+  let source;
+  try {
+    source = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const MAX_FILE_LINES = 3e3;
+  const MAX_FILE_BYTES = 2e5;
+  if (source.length > MAX_FILE_BYTES || source.split("\n").length > MAX_FILE_LINES) {
+    return null;
+  }
+  const result = pack.process(source, { language });
+  if (!result) return null;
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const symbols = [];
+  const calls = [];
+  const imports = [];
+  const sourceLines = source.split("\n");
+  const lineOffsets = [0];
+  for (let i = 0; i < sourceLines.length; i++) {
+    lineOffsets.push(lineOffsets[i] + sourceLines[i].length + 1);
+  }
+  const extractSymbols = (items, parentId) => {
+    for (const item of items) {
+      if (!item.name) continue;
+      const id = generateId();
+      const lineStart = (item.span?.startLine ?? 0) + 1;
+      const lineEnd = (item.span?.endLine ?? lineStart) + 1;
+      const bodyStart = item.span?.startLine !== void 0 ? lineOffsets[item.span.startLine] : 0;
+      const bodyEnd = item.span?.endLine !== void 0 ? lineOffsets[item.span.endLine + 1] - 1 : source.length;
+      const bodyText = source.slice(bodyStart, bodyEnd);
+      symbols.push({
+        id,
+        name: item.name,
+        kind: item.kind ?? "unknown",
+        filePath: relPath,
+        lineStart,
+        lineEnd,
+        language,
+        signature: item.signature ?? null,
+        docstring: item.docComment ?? null,
+        parentId,
+        contentHash: createHash("sha256").update(item.name + relPath + lineStart).digest("hex")
+      });
+      const bodyStartLine = lineStart;
+      const offsetToLine = (offset) => {
+        const sourceOffset = bodyStart + offset;
+        let lo = 0, hi = lineOffsets.length - 1;
+        while (lo < hi) {
+          const mid = lo + hi + 1 >> 1;
+          if (lineOffsets[mid] <= sourceOffset) lo = mid;
+          else hi = mid - 1;
+        }
+        return lo + 1;
+      };
+      const capturedOffsets = /* @__PURE__ */ new Set();
+      const jsxRegex = /<([A-Z][a-zA-Z0-9_$]*)\b/g;
+      let jMatch;
+      while ((jMatch = jsxRegex.exec(bodyText)) !== null) {
+        const calleeName = jMatch[1];
+        const offset = jMatch.index;
+        if (!isKeywordOrSelf(calleeName, item.name) && !capturedOffsets.has(offset)) {
+          calls.push({
+            callerId: id,
+            calleeName,
+            calleeId: null,
+            line: offsetToLine(offset),
+            kind: "call",
+            callType: "jsx"
+          });
+          capturedOffsets.add(offset);
+        }
+      }
+      const methodCallRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\.([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+      let mMatch;
+      while ((mMatch = methodCallRegex.exec(bodyText)) !== null) {
+        const receiver = mMatch[1];
+        const methodName = mMatch[2];
+        const calleeName = `${receiver}.${methodName}`;
+        const offset = mMatch.index;
+        if (!isKeywordOrSelf(methodName, item.name) && !isKeywordOrSelf(receiver, item.name) && !isStdlibCall(calleeName, language) && !capturedOffsets.has(offset)) {
+          calls.push({
+            callerId: id,
+            calleeName,
+            calleeId: null,
+            line: offsetToLine(offset),
+            kind: "call",
+            callType: "method"
+          });
+          capturedOffsets.add(offset);
+        }
+      }
+      const simpleCallRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+      let match;
+      while ((match = simpleCallRegex.exec(bodyText)) !== null) {
+        const calleeName = match[1];
+        const offset = match.index;
+        if (!isKeywordOrSelf(calleeName, item.name) && !isStdlibCall(calleeName, language) && !capturedOffsets.has(offset)) {
+          calls.push({
+            callerId: id,
+            calleeName,
+            calleeId: null,
+            line: offsetToLine(offset),
+            kind: "call",
+            callType: "direct"
+          });
+          capturedOffsets.add(offset);
+        }
+      }
+      if (item.children && item.children.length > 0) {
+        extractSymbols(item.children, id);
+      }
+    }
+  };
+  extractSymbols(result.structure ?? [], null);
+  for (const imp of result.imports ?? []) {
+    imports.push({
+      filePath: relPath,
+      symbolName: imp.items?.join(", ") ?? imp.source ?? "unknown",
+      sourcePath: imp.source ?? null,
+      line: (imp.span?.startLine ?? 0) + 1,
+      language
+    });
+  }
+  return { symbols, calls, imports };
+}
+function isKeywordOrSelf(name, symbolName) {
+  if (name === symbolName) return true;
+  const keywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "return",
+    "function",
+    "def",
+    "func",
+    "fn",
+    "print",
+    "console",
+    "require",
+    "import",
+    "export",
+    "class",
+    "struct",
+    "enum",
+    "interface",
+    "type",
+    "const",
+    "let",
+    "var",
+    "new",
+    "delete",
+    "typeof",
+    "instanceof",
+    "void",
+    "in",
+    "of",
+    "await",
+    "async",
+    "yield",
+    "throw",
+    "try",
+    "catch",
+    "finally",
+    "break",
+    "continue",
+    "do",
+    "else",
+    "case",
+    "default",
+    "extends",
+    "implements",
+    "super",
+    "this",
+    "self",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "nil",
+    "None",
+    "True",
+    "False",
+    "println",
+    "printf",
+    "fmt",
+    "err",
+    "panic",
+    "recover"
+  ]);
+  return keywords.has(name);
+}
+function isStdlibCall(calleeName, language) {
+  const prefixes = STDLIB_PREFIXES[language];
+  if (!prefixes) return false;
+  if (prefixes.has(calleeName)) return true;
+  const dotIdx = calleeName.indexOf(".");
+  if (dotIdx > 0) {
+    const prefix = calleeName.slice(0, dotIdx);
+    if (prefixes.has(prefix)) return true;
+  }
+  return false;
+}
+async function indexFile(db, filePath, repoPath, teamId) {
+  const language = detectLanguage(filePath);
+  if (!language) {
+    return { file: filePath, language: "unknown", symbols: 0, calls: 0, imports: 0, skipped: true };
+  }
+  const parsed = await parseFile(filePath, repoPath);
+  if (!parsed) {
+    return { file: filePath, language, symbols: 0, calls: 0, imports: 0, skipped: true };
+  }
+  const relPath = relative(repoPath, filePath).split(sep).join("/");
+  const now = Date.now();
+  const existingIds = db.prepare("SELECT id FROM symbols WHERE file_path = ? AND team_id IS ?").all(relPath, teamId);
+  if (existingIds.length > 0) {
+    const placeholders = existingIds.map(() => "?").join(",");
+    db.prepare(`DELETE FROM calls WHERE caller_id IN (${placeholders})`).run(
+      ...existingIds.map((e) => e.id)
+    );
+    db.prepare("DELETE FROM symbols WHERE file_path = ? AND team_id IS ?").run(relPath, teamId);
+  }
+  db.prepare("DELETE FROM imports WHERE file_path = ? AND team_id IS ?").run(relPath, teamId);
+  const symbolStmt = db.prepare(
+    `INSERT INTO symbols (id, name, kind, file_path, line_start, line_end, language, signature, docstring, parent_id, team_id, repo_path, content_hash, module_path, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const modulePath = relPath.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|c|cpp|cc|cxx|hpp|cs)$/, "");
+  for (const s of parsed.symbols) {
+    symbolStmt.run(
+      s.id,
+      s.name,
+      s.kind,
+      s.filePath,
+      s.lineStart,
+      s.lineEnd,
+      s.language,
+      s.signature,
+      s.docstring,
+      s.parentId,
+      teamId,
+      repoPath,
+      s.contentHash,
+      modulePath,
+      now,
+      now
+    );
+  }
+  const callStmt = db.prepare(
+    `INSERT INTO calls (caller_id, callee_name, callee_id, line, kind, call_type, team_id) VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const c of parsed.calls) {
+    callStmt.run(
+      c.callerId,
+      c.calleeName,
+      null,
+      // Will be resolved by resolveAllCalls() in indexDirectory
+      c.line,
+      c.kind,
+      c.callType ?? "direct",
+      teamId
+    );
+  }
+  const importStmt = db.prepare(
+    `INSERT INTO imports (file_path, symbol_name, source_path, line, language, team_id, repo_path) VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const imp of parsed.imports) {
+    importStmt.run(
+      imp.filePath,
+      imp.symbolName,
+      imp.sourcePath,
+      imp.line,
+      imp.language,
+      teamId,
+      repoPath
+    );
+  }
+  return {
+    file: relPath,
+    language,
+    symbols: parsed.symbols.length,
+    calls: parsed.calls.length,
+    imports: parsed.imports.length,
+    skipped: false
+  };
+}
+async function indexDirectory(db, dirPath, repoPath, teamId, maxFiles = 1e4) {
+  const results = [];
+  const files = [];
+  const walk = (dir) => {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      const fullPath = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (entry === "node_modules" || entry === ".git" || entry === "dist" || entry === "build" || entry === "target" || entry === "__pycache__" || entry === ".next" || entry === "vendor" || entry === ".venv" || entry.startsWith("."))
+          continue;
+        walk(fullPath);
+      } else if (stat.isFile()) {
+        if (detectLanguage(fullPath)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  };
+  walk(dirPath);
+  for (const file of files) {
+    const result = await indexFile(db, file, repoPath, teamId);
+    results.push(result);
+  }
+  const { resolveAllCalls } = await import("./resolver-AVK7XKX7.js");
+  const stats = resolveAllCalls(db);
+  if (stats.total > 0) {
+    console.error(
+      `[remem-mcp] indexDirectory: resolved ${stats.resolved}/${stats.total} calls` + (Object.keys(stats.byStrategy).length > 0 ? ` (${JSON.stringify(stats.byStrategy)})` : "")
+    );
+  }
+  return results;
+}
+function searchSymbols(db, query, opts = {}) {
+  const limit = opts.limit ?? 20;
+  const pattern = `%${query}%`;
+  let sql = "SELECT * FROM symbols WHERE name LIKE ?";
+  const params = [pattern];
+  if (opts.teamId !== void 0) {
+    sql += " AND team_id IS ?";
+    params.push(opts.teamId);
+  }
+  if (opts.repoPath !== void 0) {
+    sql += " AND (repo_path = ? OR repo_path LIKE ?)";
+    params.push(opts.repoPath, `${opts.repoPath}%`);
+  }
+  if (opts.kind) {
+    sql += " AND kind = ?";
+    params.push(opts.kind);
+  }
+  if (opts.language) {
+    sql += " AND language = ?";
+    params.push(opts.language);
+  }
+  sql += " LIMIT ?";
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    name: r.name,
+    kind: r.kind,
+    filePath: r.file_path,
+    lineStart: r.line_start,
+    lineEnd: r.line_end,
+    language: r.language,
+    signature: r.signature,
+    docstring: r.docstring,
+    parentId: r.parent_id,
+    contentHash: r.content_hash
+  }));
+}
+function findCallers(db, symbolId, opts = {}) {
+  const limit = opts.limit ?? 50;
+  const rows = db.prepare(
+    `SELECT s.*, c.line as call_line
+       FROM calls c
+       JOIN symbols s ON s.id = c.caller_id
+       WHERE c.callee_id = ? OR c.callee_name = (SELECT name FROM symbols WHERE id = ?)
+       LIMIT ?`
+  ).all(symbolId, symbolId, limit);
+  return rows.map((r) => ({
+    caller: {
+      id: r.id,
+      name: r.name,
+      kind: r.kind,
+      filePath: r.file_path,
+      lineStart: r.line_start,
+      lineEnd: r.line_end,
+      language: r.language,
+      signature: r.signature,
+      docstring: r.docstring,
+      parentId: r.parent_id,
+      contentHash: r.content_hash
+    },
+    line: r.call_line
+  }));
+}
+function findCallees(db, symbolId, opts = {}) {
+  const limit = opts.limit ?? 50;
+  const rows = db.prepare(
+    `SELECT c.callee_name, c.callee_id, c.line,
+              s.id as sid, s.name as sname, s.kind as skind, s.file_path as sfile,
+              s.line_start as sline_start, s.line_end as sline_end, s.language as slang,
+              s.signature as ssig, s.docstring as sdoc, s.parent_id as sparent, s.content_hash as shash
+       FROM calls c
+       LEFT JOIN symbols s ON s.id = c.callee_id
+       WHERE c.caller_id = ?
+       LIMIT ?`
+  ).all(symbolId, limit);
+  return rows.map((r) => ({
+    callee: r.sid ? {
+      id: r.sid,
+      name: r.sname ?? "",
+      kind: r.skind ?? "",
+      filePath: r.sfile ?? "",
+      lineStart: r.sline_start ?? 0,
+      lineEnd: r.sline_end ?? 0,
+      language: r.slang ?? "",
+      signature: r.ssig,
+      docstring: r.sdoc,
+      parentId: r.sparent,
+      contentHash: r.shash ?? ""
+    } : null,
+    calleeName: r.callee_name,
+    line: r.line
+  }));
+}
+function impactAnalysis(db, symbolId, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 5;
+  const rootRow = db.prepare("SELECT * FROM symbols WHERE id = ?").get(symbolId);
+  if (!rootRow) {
+    throw new Error(`Symbol not found: ${symbolId}`);
+  }
+  const root = {
+    id: rootRow.id,
+    name: rootRow.name,
+    kind: rootRow.kind,
+    filePath: rootRow.file_path,
+    lineStart: rootRow.line_start,
+    lineEnd: rootRow.line_end,
+    language: rootRow.language,
+    signature: rootRow.signature,
+    docstring: rootRow.docstring,
+    parentId: rootRow.parent_id,
+    contentHash: rootRow.content_hash
+  };
+  const affected = [];
+  const visited = /* @__PURE__ */ new Set([symbolId]);
+  const queue = [
+    { id: symbolId, depth: 0, path: [root.name] }
+  ];
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (!item) continue;
+    const { id, depth, path } = item;
+    if (depth >= maxDepth) continue;
+    const callers = findCallers(db, id, { limit: 100 });
+    for (const { caller } of callers) {
+      if (visited.has(caller.id)) continue;
+      visited.add(caller.id);
+      const newPath = [...path, caller.name];
+      affected.push({ symbol: caller, depth: depth + 1, path: newPath });
+      queue.push({ id: caller.id, depth: depth + 1, path: newPath });
+    }
+  }
+  return { rootSymbol: root, affected };
+}
+function listSymbols(db, filePath, opts = {}) {
+  const limit = opts.limit ?? 100;
+  let relPath = filePath;
+  if (opts.repoPath) {
+    try {
+      relPath = relative(opts.repoPath, filePath).split(sep).join("/");
+    } catch {
+    }
+  }
+  let sql = "SELECT * FROM symbols WHERE file_path LIKE ?";
+  const params = [`${relPath}%`];
+  if (opts.teamId !== void 0) {
+    sql += " AND team_id IS ?";
+    params.push(opts.teamId);
+  }
+  if (opts.repoPath !== void 0) {
+    sql += " AND (repo_path = ? OR repo_path LIKE ?)";
+    params.push(opts.repoPath, `${opts.repoPath}%`);
+  }
+  if (opts.kind) {
+    sql += " AND kind = ?";
+    params.push(opts.kind);
+  }
+  sql += " ORDER BY line_start LIMIT ?";
+  params.push(limit);
+  const rows = db.prepare(sql).all(...params);
+  return rows.map((r) => ({
+    id: r.id,
+    name: r.name,
+    kind: r.kind,
+    filePath: r.file_path,
+    lineStart: r.line_start,
+    lineEnd: r.line_end,
+    language: r.language,
+    signature: r.signature,
+    docstring: r.docstring,
+    parentId: r.parent_id,
+    contentHash: r.content_hash
+  }));
+}
+var _pack, EXTENSION_MAP, SUPPORTED_LANGUAGES, STDLIB_PREFIXES;
+var init_engine = __esm({
+  "src/codegraph/engine.ts"() {
+    init_esm_shims();
+    init_ulid();
+    _pack = null;
+    EXTENSION_MAP = {
+      ".ts": "typescript",
+      ".tsx": "tsx",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".hpp": "cpp",
+      ".cs": "csharp"
+    };
+    SUPPORTED_LANGUAGES = new Set(Object.values(EXTENSION_MAP));
+    STDLIB_PREFIXES = {
+      go: /* @__PURE__ */ new Set([
+        "fmt",
+        "json",
+        "os",
+        "io",
+        "strings",
+        "strconv",
+        "time",
+        "errors",
+        "sync",
+        "context",
+        "path",
+        "filepath",
+        "sort",
+        "bytes",
+        "bufio",
+        "encoding",
+        "net",
+        "http",
+        "url",
+        "regexp",
+        "math",
+        "log",
+        "reflect",
+        "runtime",
+        "unsafe",
+        "atomic",
+        "crypto",
+        "hash",
+        "base64",
+        "hex",
+        "ioutil",
+        "filepath",
+        "unicode",
+        "testing",
+        "flag",
+        "env"
+      ]),
+      typescript: /* @__PURE__ */ new Set([
+        "console",
+        "JSON",
+        "Math",
+        "Date",
+        "Object",
+        "Array",
+        "String",
+        "Number",
+        "Boolean",
+        "Promise",
+        "Symbol",
+        "Map",
+        "Set",
+        "WeakMap",
+        "WeakSet",
+        "Error",
+        "RegExp",
+        "Buffer",
+        "process",
+        "setTimeout",
+        "setInterval",
+        "clearTimeout",
+        "clearInterval",
+        "fetch",
+        "URL",
+        "URLSearchParams",
+        "FormData",
+        "Headers",
+        "Request",
+        "Response",
+        "AbortController",
+        "Event",
+        "EventTarget",
+        "CustomEvent",
+        "TextEncoder",
+        "TextDecoder",
+        "crypto",
+        "performance",
+        "queueMicrotask",
+        "atob",
+        "btoa",
+        "parseInt",
+        "parseFloat",
+        "isNaN",
+        "isFinite",
+        "encodeURIComponent",
+        "decodeURIComponent",
+        "encodeURI",
+        "decodeURI"
+      ]),
+      javascript: /* @__PURE__ */ new Set([
+        "console",
+        "JSON",
+        "Math",
+        "Date",
+        "Object",
+        "Array",
+        "String",
+        "Number",
+        "Boolean",
+        "Promise",
+        "Symbol",
+        "Map",
+        "Set",
+        "WeakMap",
+        "WeakSet",
+        "Error",
+        "RegExp",
+        "Buffer",
+        "process",
+        "setTimeout",
+        "setInterval",
+        "clearTimeout",
+        "clearInterval",
+        "fetch",
+        "URL",
+        "URLSearchParams",
+        "FormData",
+        "Headers",
+        "Request",
+        "Response",
+        "AbortController",
+        "Event",
+        "EventTarget",
+        "CustomEvent",
+        "TextEncoder",
+        "TextDecoder",
+        "crypto",
+        "performance",
+        "queueMicrotask",
+        "atob",
+        "btoa",
+        "parseInt",
+        "parseFloat",
+        "isNaN",
+        "isFinite",
+        "encodeURIComponent",
+        "decodeURIComponent",
+        "encodeURI",
+        "decodeURI"
+      ]),
+      python: /* @__PURE__ */ new Set([
+        "print",
+        "len",
+        "range",
+        "str",
+        "int",
+        "float",
+        "bool",
+        "list",
+        "dict",
+        "set",
+        "tuple",
+        "type",
+        "isinstance",
+        "issubclass",
+        "id",
+        "hash",
+        "dir",
+        "vars",
+        "globals",
+        "locals",
+        "exec",
+        "eval",
+        "compile",
+        "open",
+        "input",
+        "repr",
+        "format",
+        "chr",
+        "ord",
+        "hex",
+        "oct",
+        "bin",
+        "abs",
+        "min",
+        "max",
+        "sum",
+        "round",
+        "pow",
+        "divmod",
+        "sorted",
+        "reversed",
+        "enumerate",
+        "zip",
+        "map",
+        "filter",
+        "any",
+        "all",
+        "next",
+        "iter",
+        "getattr",
+        "setattr",
+        "hasattr",
+        "delattr",
+        "property",
+        "staticmethod",
+        "classmethod",
+        "super",
+        "object",
+        "Exception",
+        "ValueError",
+        "TypeError",
+        "KeyError",
+        "IndexError",
+        "AttributeError",
+        "RuntimeError",
+        "StopIteration",
+        "os",
+        "sys",
+        "json",
+        "re",
+        "time",
+        "datetime",
+        "pathlib",
+        "typing",
+        "collections",
+        "itertools",
+        "functools",
+        "subprocess",
+        "argparse",
+        "logging",
+        "unittest",
+        "asyncio",
+        "threading",
+        "multiprocessing",
+        "pickle",
+        "shutil",
+        "tempfile",
+        "glob",
+        "fnmatch",
+        "csv",
+        "io",
+        "base64",
+        "hashlib",
+        "hmac",
+        "secrets",
+        "uuid",
+        "copy",
+        "math",
+        "random",
+        "statistics",
+        "decimal",
+        "fractions",
+        "sqlite3"
+      ]),
+      rust: /* @__PURE__ */ new Set([
+        "println",
+        "print",
+        "eprintln",
+        "eprint",
+        "format",
+        "vec",
+        "String",
+        "Vec",
+        "Option",
+        "Result",
+        "Some",
+        "None",
+        "Ok",
+        "Err",
+        "Box",
+        "Rc",
+        "Arc",
+        "RefCell",
+        "Cell",
+        "Mutex",
+        "RwLock",
+        "HashMap",
+        "HashSet",
+        "BTreeMap",
+        "BTreeSet",
+        "VecDeque",
+        "LinkedList",
+        "std",
+        "core",
+        "alloc",
+        "macro",
+        "todo",
+        "unimplemented",
+        "panic",
+        "assert",
+        "assert_eq",
+        "assert_ne",
+        "debug_assert",
+        "debug_assert_eq",
+        "cfg",
+        "env",
+        "include",
+        "concat",
+        "stringify",
+        "file",
+        "line",
+        "module_path",
+        "column",
+        "format_args",
+        "write",
+        "writeln"
+      ])
+    };
+  }
+});
+
+export {
+  generateId,
+  init_ulid,
+  SUPPORTED_LANGUAGES,
+  detectLanguage,
+  parseFile,
+  indexFile,
+  indexDirectory,
+  searchSymbols,
+  findCallers,
+  findCallees,
+  impactAnalysis,
+  listSymbols,
+  engine_exports,
+  init_engine
+};
+//# sourceMappingURL=chunk-FA324IBN.js.map