@openez-graph/cli 0.4.3 → 0.5.1

package/dist/cli.cjs

@@ -12147,7 +12147,7 @@ function createWorkspaceRepository(rootPath) {
     },
     // ── Graph Node Operations ──
     async upsertGraphNode(input) {
-      const existing = native.prepare("SELECT * FROM graph_nodes WHERE type = ? AND label = ?").get(input.type, input.label);
+      const existing = input.type === "symbol" && input.refId ? native.prepare("SELECT * FROM graph_nodes WHERE type = ? AND label = ? AND ref_id = ?").get(input.type, input.label, input.refId) : native.prepare("SELECT * FROM graph_nodes WHERE type = ? AND label = ?").get(input.type, input.label);
       if (existing) {
         const nextMetadata = input.metadata ?? String(existing.metadata ?? "{}");
         const existingRefId = existing.ref_id ?? null;
@@ -200816,9 +200816,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             if (packageName === void 0) return void 0;
             switch (context.fixId) {
               case fixIdInstallTypesPackage: {
-                const pkg = getTypesPackageNameToInstall(packageName, context.host, diag2.code);
-                if (pkg) {
-                  commands.push(getInstallCommand(diag2.file.fileName, pkg));
+                const pkg2 = getTypesPackageNameToInstall(packageName, context.host, diag2.code);
+                if (pkg2) {
+                  commands.push(getInstallCommand(diag2.file.fileName, pkg2));
                 }
                 break;
               }
@@ -302577,7 +302577,14 @@ function indexCode(content, filePath) {
   }
   return {
     chunks: chunks2,
-    importPaths: sourceFile.getImportDeclarations().map((declaration) => declaration.getModuleSpecifierValue()),
+    importPaths: sourceFile.getImportDeclarations().flatMap((declaration) => {
+      try {
+        const value = declaration.getModuleSpecifierValue();
+        return typeof value === "string" && value.length > 0 ? [value] : [];
+      } catch {
+        return [];
+      }
+    }),
     definedSymbols,
     calledIdentifiers: [...calledIdentifiers],
     callExpressions
@@ -302769,6 +302776,10 @@ var init_markdown = __esm({
 });
 
 // ../../packages/indexer/src/languages.ts
+function codeSearchText2(text2) {
+  const identifiers = text2.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? [];
+  return [...new Set(identifiers.flatMap((identifier) => identifier.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/_/g, " ").split(" ").filter((term) => term.length > 1)))].slice(0, 256).join(" ");
+}
 function inferDocumentKind(filePath) {
   const extension = import_node_path9.default.extname(filePath).toLowerCase();
   if (markdownExtensions.has(extension)) {
@@ -302782,6 +302793,75 @@ function inferDocumentKind(filePath) {
   }
   return { kind: "text", language: extension.slice(1) || null, extension };
 }
+function isEscaped(text2, index2) {
+  let slashes = 0;
+  while (text2[index2 - slashes - 1] === "\\") slashes++;
+  return slashes % 2 === 1;
+}
+function stripNonCode(content, options = {}) {
+  let result = "";
+  let quote = "";
+  let blockComment = false;
+  let lineComment = false;
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    const next = content[i + 1];
+    const triple = content.slice(i, i + 3);
+    if (char === "\n") {
+      result += "\n";
+      lineComment = false;
+      continue;
+    }
+    if (lineComment) {
+      result += " ";
+      continue;
+    }
+    if (blockComment) {
+      result += " ";
+      if (char === "*" && next === "/") {
+        result += " ";
+        blockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (quote) {
+      result += " ";
+      if (quote.length === 3 && triple === quote) {
+        result += "  ";
+        quote = "";
+        i += 2;
+      } else if (quote.length === 1 && char === quote && !isEscaped(content, i)) {
+        quote = "";
+      }
+      continue;
+    }
+    if (options.hashComments && char === "#") {
+      result += " ";
+      lineComment = true;
+    } else if (!options.hashComments && char === "/" && next === "/") {
+      result += "  ";
+      lineComment = true;
+      i++;
+    } else if (!options.hashComments && char === "/" && next === "*") {
+      result += "  ";
+      blockComment = true;
+      i++;
+    } else if (options.tripleStrings && (triple === '"""' || triple === "'''")) {
+      result += "   ";
+      quote = triple;
+      i += 2;
+    } else if (options.rustLifetimes && char === "'" && /[A-Za-z_]/.test(next ?? "") && content[i + 2] !== "'") {
+      result += char;
+    } else if (char === '"' || char === "'" || options.backtickStrings && char === "`") {
+      result += " ";
+      quote = char;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
 function stripPythonAlias(value) {
   return value.trim().replace(/^\(+|\)+$/g, "").split(/\s+as\s+/i)[0]?.trim() ?? "";
 }
@@ -302806,84 +302886,160 @@ function normalizePythonCallName(value) {
 }
 function parsePython(content) {
   const lines = content.split("\n");
+  const codeLines = stripNonCode(content, { hashComments: true, tripleStrings: true }).split("\n");
   const definedSymbols = [];
   const importPaths = [];
   const calledIdentifiers = /* @__PURE__ */ new Set();
   const callExpressions = [];
   const symbolRegex = /^(?:async\s+)?(?:def|class)\s+(\w+)/;
-  const moduleDocstring = /^"""/;
   const callRegex = /(\w+(?:\.\w+)*)\s*\(/g;
-  let inMultilineString = false;
+  const decoratorRegex = /^@(\w+(?:\.\w+)*)/;
+  let pendingDecorators = [];
+  const symbolStack = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (inMultilineString) {
-      if (line.includes('"""') || line.includes("'''")) {
-        inMultilineString = false;
+    while (symbolStack.length > 0 && i >= symbolStack[symbolStack.length - 1].endLine) {
+      symbolStack.pop();
+    }
+    const trimmed = codeLines[i].trim();
+    const decoratorMatch = decoratorRegex.exec(trimmed);
+    if (decoratorMatch) {
+      pendingDecorators.push({ name: decoratorMatch[1], lineIndex: i });
+      const decoratorCalls = decoratorMatch[1];
+      const decoratorCalledName = normalizePythonCallName(decoratorCalls);
+      if (!PYTHON_CALL_IGNORES.has(decoratorCalledName)) {
+        calledIdentifiers.add(decoratorCalledName);
       }
       continue;
     }
-    if (moduleDocstring.test(line.trim())) {
-      if (!line.trim().endsWith('"""') && !line.trim().endsWith("'''")) {
-        inMultilineString = true;
-      }
-      continue;
-    }
-    const trimmed = line.trim();
     const symbolMatch = symbolRegex.exec(trimmed);
     if (symbolMatch) {
-      const name = symbolMatch[1];
+      const rawName = symbolMatch[1];
       const isAsync2 = trimmed.startsWith("async");
       const stripped = isAsync2 ? trimmed.slice(6) : trimmed;
       const symbolType2 = stripped.startsWith("def") ? "function" : "class";
-      const exported = !name.startsWith("_");
-      const startLine = i + 1;
-      const endLine = findBlockEnd(lines, i);
-      const content2 = lines.slice(i, endLine).join("\n");
-      definedSymbols.push({ name, symbolType: symbolType2, type: symbolType2, exported, startLine, endLine });
-      const bodyContent = lines.slice(i, endLine).join("\n");
+      const exported = !rawName.startsWith("_");
+      const endLine = findBlockEnd(codeLines, i);
+      const parentName = symbolStack.length > 0 ? symbolStack[symbolStack.length - 1].name : null;
+      const name = parentName ? `${parentName}::${rawName}` : rawName;
+      const decoratorNames = pendingDecorators.map((d) => d.name);
+      const decoratorStartLine = pendingDecorators.length > 0 ? pendingDecorators[0].lineIndex + 1 : i + 1;
+      const startLine = decoratorStartLine;
+      const content2 = lines.slice(startLine - 1, endLine).join("\n");
+      definedSymbols.push({ name, symbolType: symbolType2, type: symbolType2, exported, startLine, endLine, decorators: decoratorNames });
+      const bodyContent = codeLines.slice(i, endLine).join("\n");
       let callMatch;
       const localCallRegex = new RegExp(callRegex);
       while ((callMatch = localCallRegex.exec(bodyContent)) !== null) {
         const rawCalledName = callMatch[1];
         const calledName = normalizePythonCallName(rawCalledName);
-        if (!PYTHON_CALL_IGNORES.has(rawCalledName) && !PYTHON_CALL_IGNORES.has(calledName) && calledName !== name) {
+        if (!PYTHON_CALL_IGNORES.has(rawCalledName) && !PYTHON_CALL_IGNORES.has(calledName) && calledName !== rawName && calledName !== name) {
           calledIdentifiers.add(calledName);
           callExpressions.push({ callerName: name, calleeName: calledName });
         }
       }
+      for (const dec of pendingDecorators) {
+        const decCalledName = normalizePythonCallName(dec.name);
+        if (!PYTHON_CALL_IGNORES.has(decCalledName) && decCalledName !== name) {
+          calledIdentifiers.add(decCalledName);
+          callExpressions.push({ callerName: name, calleeName: decCalledName });
+        }
+        const decLine = codeLines[dec.lineIndex];
+        let decCallMatch;
+        const decCallRegex = new RegExp(callRegex);
+        while ((decCallMatch = decCallRegex.exec(decLine)) !== null) {
+          const rawCalledName = decCallMatch[1];
+          const calledName = normalizePythonCallName(rawCalledName);
+          if (!PYTHON_CALL_IGNORES.has(rawCalledName) && !PYTHON_CALL_IGNORES.has(calledName) && calledName !== name && calledName !== decCalledName) {
+            calledIdentifiers.add(calledName);
+            callExpressions.push({ callerName: name, calleeName: calledName });
+          }
+        }
+      }
+      pendingDecorators = [];
+      symbolStack.push({ name, endLine });
     }
     importPaths.push(...parsePythonImportLine(line));
   }
   const chunks2 = createSymbolChunks(definedSymbols, lines, "python");
   if (chunks2.length === 0) {
-    return { ...makeFallbackChunks(content, lines), callExpressions: [] };
+    return { ...makeFallbackChunks(content, lines), importPaths: [...new Set(importPaths)] };
   }
   return { chunks: chunks2, importPaths: [...new Set(importPaths)], definedSymbols, calledIdentifiers: [...calledIdentifiers], callExpressions };
 }
+function normalizeGoCallName(value) {
+  const parts = value.split(".").filter(Boolean);
+  return parts[parts.length - 1] ?? value;
+}
+function parseGoImports(lines) {
+  const imports = [];
+  const singleImportRegex = /^import\s+(?:[.\w]+\s+)?"([^"]+)"/;
+  const groupedImportPathRegex = /^\s*(?:[.\w]+\s+)?"([^"]+)"/;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "import (" || /^import\s*\(/.test(trimmed)) {
+      for (let j = i + 1; j < lines.length; j++) {
+        const innerTrimmed = lines[j].trim();
+        if (innerTrimmed === ")") break;
+        const pathMatch = groupedImportPathRegex.exec(lines[j]);
+        if (pathMatch) {
+          imports.push(pathMatch[1]);
+        }
+      }
+      continue;
+    }
+    const singleMatch = singleImportRegex.exec(trimmed);
+    if (singleMatch) {
+      imports.push(singleMatch[1]);
+    }
+  }
+  return imports;
+}
 function parseGo(content) {
   const lines = content.split("\n");
+  const codeLines = stripNonCode(content, { backtickStrings: true }).split("\n");
   const definedSymbols = [];
-  const importPaths = [];
-  const funcRegex = /^func\s+(?:\([^)]*\)\s+)?(\w+)/;
+  const calledIdentifiers = /* @__PURE__ */ new Set();
+  const callExpressions = [];
+  const funcRegex = /^func\s+(?:\(([^)]*)\)\s+)?(\w+)/;
   const typeRegex = /^type\s+(\w+)\s+(?:struct|interface|func|map|chan|\w+)/;
   const constVarRegex = /^(?:const|var)\s+(\w+)/;
-  const importRegex = /^import\s+(?:"(\S+)"|\(|(\S+))/;
+  const callRegex = /(\w+(?:\.\w+)*)\s*\(/g;
+  const importPaths = parseGoImports(lines);
   for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
+    const trimmed = codeLines[i].trim();
     const funcMatch = funcRegex.exec(trimmed);
     if (funcMatch) {
-      const name = funcMatch[1];
+      const receiver = funcMatch[1]?.trim();
+      const name = funcMatch[2];
+      const receiverParts = receiver?.match(/[A-Za-z_]\w*/g) ?? [];
+      const receiverName = receiverParts[0];
+      const receiverType = receiverParts[receiverParts.length - 1];
       const exported = name[0] >= "A" && name[0] <= "Z";
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
+      const endLine = findBraceBlockEnd(codeLines, i);
+      const symbolName = receiverType ? `${receiverType}::${name}` : name;
       definedSymbols.push({
-        name,
+        name: symbolName,
         symbolType: "function",
         type: "function",
         exported,
         startLine,
-        endLine
+        endLine,
+        ...receiver ? { receiver: receiver.trim() } : {}
       });
+      const bodyContent = codeLines.slice(i, endLine).join("\n");
+      let callMatch;
+      const localCallRegex = new RegExp(callRegex);
+      while ((callMatch = localCallRegex.exec(bodyContent)) !== null) {
+        const rawCalledName = callMatch[1];
+        const calledName = normalizeGoCallName(rawCalledName);
+        const calleeName = receiverName && rawCalledName.startsWith(`${receiverName}.`) && receiverType ? `${receiverType}::${calledName}` : calledName;
+        if (!GO_CALL_IGNORES.has(rawCalledName) && !GO_CALL_IGNORES.has(calledName) && calleeName !== symbolName) {
+          calledIdentifiers.add(calleeName);
+          callExpressions.push({ callerName: symbolName, calleeName });
+        }
+      }
       continue;
     }
     const typeMatch = typeRegex.exec(trimmed);
@@ -302891,7 +303047,7 @@ function parseGo(content) {
       const name = typeMatch[1];
       const exported = name[0] >= "A" && name[0] <= "Z";
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
+      const endLine = findBraceBlockEnd(codeLines, i);
       definedSymbols.push({
         name,
         symbolType: "type",
@@ -302915,40 +303071,115 @@ function parseGo(content) {
         endLine: i + 1
       });
     }
-    const importMatch = importRegex.exec(trimmed);
-    if (importMatch) {
-      const pkg = importMatch[1] || importMatch[2];
-      importPaths.push(pkg);
-    }
   }
   const chunks2 = createSymbolChunks(definedSymbols, lines, "go");
   if (chunks2.length === 0) {
-    return makeFallbackChunks(content, lines);
+    return { ...makeFallbackChunks(content, lines), importPaths };
   }
-  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [], callExpressions: [] };
+  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [...calledIdentifiers], callExpressions };
+}
+function normalizeRustCallName(value) {
+  const parts = value.split("::").filter(Boolean);
+  const last = parts[parts.length - 1] ?? value;
+  const dotParts = last.split(".");
+  return dotParts[dotParts.length - 1] ?? last;
 }
 function parseRust(content) {
   const lines = content.split("\n");
+  const codeLines = stripNonCode(content, { rustLifetimes: true }).split("\n");
   const definedSymbols = [];
   const importPaths = [];
-  const fnRegex = /^(?:pub\s+)?(?:unsafe\s+)?fn\s+(\w+)/;
+  const calledIdentifiers = /* @__PURE__ */ new Set();
+  const callExpressions = [];
+  const fnRegex = /^(?:pub\s+)?(?:unsafe\s+)?(?:async\s+)?fn\s+(\w+)/;
   const structRegex = /^(?:pub\s+)?struct\s+(\w+)/;
   const enumRegex = /^(?:pub\s+)?enum\s+(\w+)/;
   const traitRegex = /^(?:pub\s+)?trait\s+(\w+)/;
-  const implRegex = /^(?:pub\s+)?impl\s+/;
+  const implRegex = /^(?:pub\s+)?impl\s+(?:<[^>]+>\s+)?([\w<>:,\s]+?)\s*(?:\{|for\s+)/;
+  const implForRegex = /^(?:pub\s+)?impl\s+(?:<[^>]+>\s+)?(\w+)\s+for\s+([\w]+(?:<[^>]+>)?)/;
   const typeRegex = /^(?:pub\s+)?type\s+(\w+)/;
   const constRegex = /^(?:pub\s+)?(?:const|static)\s+(\w+)/;
   const modRegex = /^(?:pub\s+)?mod\s+(\w+)/;
-  const useRegex = /^use\s+(\S+)/;
+  const useRegex = /^(?:pub(?:\([^)]*\))?\s+)?use\s+(.+?);?$/;
+  const callRegex = /(\w+(?:::\w+)*(?:\.\w+)*)\s*\(/g;
+  let implContext = null;
+  let implBraceDepth = 0;
+  let traitContext = null;
+  let traitBraceDepth = 0;
   for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
+    const trimmed = codeLines[i].trim();
+    if (implContext) {
+      implBraceDepth += countBraces(codeLines[i]);
+      if (implBraceDepth <= 0) {
+        implContext = null;
+        implBraceDepth = 0;
+        continue;
+      }
+    }
+    if (traitContext) {
+      traitBraceDepth += countBraces(codeLines[i]);
+      if (traitBraceDepth <= 0) {
+        traitContext = null;
+        traitBraceDepth = 0;
+        continue;
+      }
+    }
+    const implForMatch = implForRegex.exec(trimmed);
+    if (implForMatch) {
+      const traitName = implForMatch[1];
+      const typeName = implForMatch[2].trim();
+      const startLine = i + 1;
+      const endLine = findBraceBlockEnd(codeLines, i);
+      definedSymbols.push({
+        name: `impl ${traitName} for ${typeName}`,
+        symbolType: "impl",
+        type: "impl",
+        exported: false,
+        startLine,
+        endLine
+      });
+      implContext = typeName;
+      implBraceDepth = countBraces(codeLines[i]);
+      if (implBraceDepth <= 0) implContext = null;
+      continue;
+    }
+    const implMatch = implRegex.exec(trimmed);
+    if (implMatch && !implForMatch) {
+      const typeName = implMatch[1].trim();
+      const startLine = i + 1;
+      const endLine = findBraceBlockEnd(codeLines, i);
+      definedSymbols.push({
+        name: `impl ${typeName}`,
+        symbolType: "impl",
+        type: "impl",
+        exported: false,
+        startLine,
+        endLine
+      });
+      implContext = typeName;
+      implBraceDepth = countBraces(codeLines[i]);
+      if (implBraceDepth <= 0) implContext = null;
+      continue;
+    }
     const fnMatch = fnRegex.exec(trimmed);
     if (fnMatch) {
       const name = fnMatch[1];
       const exported = trimmed.startsWith("pub");
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
-      definedSymbols.push({ name, symbolType: "function", type: "function", exported, startLine, endLine });
+      const endLine = trimmed.endsWith(";") ? i + 1 : findBraceBlockEnd(codeLines, i);
+      const symbolName = implContext ? `${implContext}::${name}` : traitContext ? `${traitContext}::${name}` : name;
+      definedSymbols.push({ name: symbolName, symbolType: "function", type: "function", exported, startLine, endLine });
+      const bodyContent = codeLines.slice(i, endLine).join("\n");
+      let callMatch;
+      const localCallRegex = new RegExp(callRegex);
+      while ((callMatch = localCallRegex.exec(bodyContent)) !== null) {
+        const rawCalledName = callMatch[1];
+        const calledName = normalizeRustCallName(rawCalledName);
+        if (!RUST_CALL_IGNORES.has(rawCalledName) && !RUST_CALL_IGNORES.has(calledName) && calledName !== name && calledName !== symbolName) {
+          calledIdentifiers.add(calledName);
+          callExpressions.push({ callerName: symbolName, calleeName: calledName });
+        }
+      }
       continue;
     }
     const structMatch = structRegex.exec(trimmed);
@@ -302956,7 +303187,7 @@ function parseRust(content) {
       const name = structMatch[1];
       const exported = trimmed.startsWith("pub");
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
+      const endLine = findBraceBlockEnd(codeLines, i);
       definedSymbols.push({ name, symbolType: "struct", type: "struct", exported, startLine, endLine });
       continue;
     }
@@ -302965,17 +303196,20 @@ function parseRust(content) {
       const name = enumMatch[1];
       const exported = trimmed.startsWith("pub");
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
+      const endLine = findBraceBlockEnd(codeLines, i);
       definedSymbols.push({ name, symbolType: "enum", type: "enum", exported, startLine, endLine });
       continue;
     }
     const traitMatch = traitRegex.exec(trimmed);
-    if (traitMatch && !implRegex.test(trimmed)) {
+    if (traitMatch && !implRegex.test(trimmed) && !implForRegex.test(trimmed)) {
       const name = traitMatch[1];
       const exported = trimmed.startsWith("pub");
       const startLine = i + 1;
-      const endLine = findBraceBlockEnd(lines, i);
+      const endLine = findBraceBlockEnd(codeLines, i);
       definedSymbols.push({ name, symbolType: "trait", type: "trait", exported, startLine, endLine });
+      traitContext = name;
+      traitBraceDepth = countBraces(codeLines[i]);
+      if (traitBraceDepth <= 0) traitContext = null;
       continue;
     }
     const typeMatch = typeRegex.exec(trimmed);
@@ -303003,7 +303237,7 @@ function parseRust(content) {
       });
     }
     const modMatch = modRegex.exec(trimmed);
-    if (modMatch && !lines[i + 1]?.trim().startsWith(";")) {
+    if (modMatch) {
       const name = modMatch[1];
       definedSymbols.push({
         name,
@@ -303011,19 +303245,19 @@ function parseRust(content) {
         type: "module",
         exported: trimmed.startsWith("pub"),
         startLine: i + 1,
-        endLine: findBraceBlockEnd(lines, i)
+        endLine: trimmed.endsWith(";") ? i + 1 : findBraceBlockEnd(codeLines, i)
       });
     }
     const useMatch = useRegex.exec(trimmed);
     if (useMatch) {
-      importPaths.push(useMatch[1]);
+      importPaths.push(useMatch[1].replace(/;$/, ""));
     }
   }
   const chunks2 = createSymbolChunks(definedSymbols, lines, "rust");
   if (chunks2.length === 0) {
-    return makeFallbackChunks(content, lines);
+    return { ...makeFallbackChunks(content, lines), importPaths };
   }
-  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [], callExpressions: [] };
+  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [...calledIdentifiers], callExpressions };
 }
 function indexConfig(content, language) {
   switch (language) {
@@ -303043,6 +303277,7 @@ function parseYamlConfig(content) {
   let currentSection = [];
   let currentKey = "root";
   let sectionStartLine = 1;
+  let sectionIndent = 0;
   const flush = (endLine) => {
     const text2 = currentSection.join("\n").trim();
     if (!text2) return;
@@ -303062,14 +303297,31 @@ function parseYamlConfig(content) {
   };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const topLevelMatch = /^(\w[\w\s.-]*?):/.exec(line);
-    if (topLevelMatch && (line.trim() === line || line.startsWith(topLevelMatch[1]))) {
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      currentSection.push(line);
+      continue;
+    }
+    const indent = line.search(/\S/);
+    const keyMatch = /^(\s*)([\w][\w\s.-]*?):(\s|$)/.exec(line);
+    const bareListItemMatch = /^(\s*)-\s/.exec(line);
+    const isTopLevel = indent === 0;
+    const isListSection = bareListItemMatch && indent < sectionIndent;
+    if (keyMatch && isTopLevel || isListSection) {
       if (currentSection.length > 0) {
         flush(i);
       }
       currentSection = [line];
-      currentKey = topLevelMatch[1].trim();
+      currentKey = keyMatch ? keyMatch[2].trim() : `list-item-${i + 1}`;
       sectionStartLine = i + 1;
+      sectionIndent = indent;
+    } else if (keyMatch && indent < sectionIndent) {
+      if (currentSection.length > 0) {
+        flush(i);
+      }
+      currentSection = [line];
+      currentKey = keyMatch[2].trim();
+      sectionStartLine = i + 1;
+      sectionIndent = indent;
     } else {
       currentSection.push(line);
     }
@@ -303114,6 +303366,7 @@ function parseTomlConfig(content) {
   let currentSection = [];
   let currentKey = "root";
   let sectionStartLine = 1;
+  let isArrayTable = false;
   const flush = (endLine) => {
     const text2 = currentSection.join("\n").trim();
     if (!text2) return;
@@ -303126,6 +303379,7 @@ function parseTomlConfig(content) {
         kind: "config",
         language: "toml",
         section: currentKey,
+        arrayTable: isArrayTable,
         startLine: sectionStartLine,
         endLine
       }
@@ -303133,13 +303387,28 @@ function parseTomlConfig(content) {
   };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    const sectionMatch = /^\[([^\]]+)\]/.exec(line.trim());
-    if (sectionMatch) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      currentSection.push(line);
+      continue;
+    }
+    const arrayTableMatch = /^\[\[([^\]]+)\]\]/.exec(trimmed);
+    const tableMatch = /^\[([^\]]+)\]/.exec(trimmed);
+    if (arrayTableMatch) {
       if (currentSection.length > 0) {
         flush(i);
       }
       currentSection = [line];
-      currentKey = sectionMatch[1];
+      currentKey = arrayTableMatch[1];
+      isArrayTable = true;
+      sectionStartLine = i + 1;
+    } else if (tableMatch) {
+      if (currentSection.length > 0) {
+        flush(i);
+      }
+      currentSection = [line];
+      currentKey = tableMatch[1];
+      isArrayTable = false;
       sectionStartLine = i + 1;
     } else {
       currentSection.push(line);
@@ -303198,6 +303467,14 @@ function findBraceBlockEnd(lines, startIndex) {
   }
   return lines.length;
 }
+function countBraces(line) {
+  let count = 0;
+  for (const char of line) {
+    if (char === "{") count++;
+    else if (char === "}") count--;
+  }
+  return count;
+}
 function findSemicolonEnd(lines, startIndex) {
   for (let i = startIndex; i < lines.length; i++) {
     if (lines[i].trim().endsWith(";")) {
@@ -303218,12 +303495,14 @@ function createSymbolChunks(symbols, allLines, language) {
       symbolType: symbol.symbolType,
       metadata: {
         kind: "code",
+        searchText: codeSearchText2(content),
         language,
         symbolName: symbol.name,
         symbolType: symbol.symbolType,
         exported: symbol.exported,
         startLine: symbol.startLine,
-        endLine: symbol.endLine
+        endLine: symbol.endLine,
+        ...symbol.decorators && symbol.decorators.length > 0 ? { decorators: symbol.decorators } : {}
       }
     };
   });
@@ -303239,6 +303518,7 @@ function makeFallbackChunks(content, lines) {
       contentHash: hashContent(slice),
       metadata: {
         kind: "code",
+        searchText: codeSearchText2(slice),
         fallback: true,
         startLine: index2 + 1,
         endLine: Math.min(index2 + 80, lines.length)
@@ -303247,7 +303527,7 @@ function makeFallbackChunks(content, lines) {
   }
   return { chunks: chunks2, importPaths: [], definedSymbols: [], calledIdentifiers: [], callExpressions: [] };
 }
-var import_node_path9, codeExtensions, configExtensions, markdownExtensions, PYTHON_CALL_IGNORES;
+var import_node_path9, codeExtensions, configExtensions, markdownExtensions, PYTHON_CALL_IGNORES, GO_CALL_IGNORES, RUST_CALL_IGNORES;
 var init_languages = __esm({
   "../../packages/indexer/src/languages.ts"() {
     "use strict";
@@ -303298,6 +303578,53 @@ var init_languages = __esm({
       "self",
       "cls"
     ]);
+    GO_CALL_IGNORES = /* @__PURE__ */ new Set([
+      "if",
+      "for",
+      "switch",
+      "select",
+      "case",
+      "go",
+      "defer",
+      "return",
+      "make",
+      "len",
+      "cap",
+      "append",
+      "copy",
+      "delete",
+      "panic",
+      "recover",
+      "new",
+      "print",
+      "println",
+      "close",
+      "complex",
+      "real",
+      "imag"
+    ]);
+    RUST_CALL_IGNORES = /* @__PURE__ */ new Set([
+      "if",
+      "while",
+      "for",
+      "loop",
+      "match",
+      "return",
+      "let",
+      "as",
+      "in",
+      "println",
+      "print",
+      "eprintln",
+      "eprint",
+      "format",
+      "vec",
+      "Box",
+      "Some",
+      "None",
+      "Ok",
+      "Err"
+    ]);
   }
 });
 
@@ -303702,7 +304029,7 @@ async function indexWorkspace(input) {
   let filesUpdated = 0;
   let chunksWritten = 0;
   let embeddingsWritten = 0;
-  const symbolNodeIdsByName = /* @__PURE__ */ new Map();
+  const symbolNodeIdsByFileAndName = /* @__PURE__ */ new Map();
   const pendingCallEdges = [];
   try {
     await reportProgress(
@@ -303796,7 +304123,8 @@ async function indexWorkspace(input) {
         });
         const symbolName = indexed.chunks[ci].symbolName;
         if (symbolName) {
-          const symbolNodeId = await repo.upsertGraphNode({
+          const fileSymbolKey = `${file.relativePath}\0${symbolName}`;
+          const symbolNodeId = symbolNodeIdsByFileAndName.get(fileSymbolKey) ?? await repo.upsertGraphNode({
             type: "symbol",
             label: symbolName,
             refId: chunkId,
@@ -303815,10 +304143,11 @@ async function indexWorkspace(input) {
             toNodeId: chunkNodeId,
             type: "represented_by"
           });
-          symbolNodeIdsByName.set(symbolName, symbolNodeId);
+          symbolNodeIdsByFileAndName.set(fileSymbolKey, symbolNodeId);
         }
       }
       for (const importPath of indexed.importPaths) {
+        if (typeof importPath !== "string" || importPath.length === 0) continue;
         const resolvedImportPath = workspaceFileResolver?.resolveImport(file.relativePath, importPath, indexed.language ?? void 0);
         if (!resolvedImportPath) continue;
         const targetNodeId = await repo.upsertGraphNode({
@@ -303845,7 +304174,7 @@ async function indexWorkspace(input) {
           type: "mentions"
         });
       }
-      pendingCallEdges.push(...indexed.callExpressions);
+      pendingCallEdges.push(...indexed.callExpressions.map((call) => ({ ...call, filePath: file.relativePath })));
       const chunkRows = chunkIds.map((id, i) => ({
         id,
         content: indexed.chunks[i].content,
@@ -303858,8 +304187,13 @@ async function indexWorkspace(input) {
     }
     const insertedCallEdges = /* @__PURE__ */ new Set();
     for (const callExpression of pendingCallEdges) {
-      const callerNodeId = symbolNodeIdsByName.get(callExpression.callerName) ?? (await repo.findGraphNode("symbol", callExpression.callerName))?.id;
-      const calleeNodeId = symbolNodeIdsByName.get(callExpression.calleeName) ?? (await repo.findGraphNode("symbol", callExpression.calleeName))?.id;
+      const callerNodeId = symbolNodeIdsByFileAndName.get(`${callExpression.filePath}\0${callExpression.callerName}`);
+      const sameFileCallee = symbolNodeIdsByFileAndName.get(`${callExpression.filePath}\0${callExpression.calleeName}`);
+      const globalCallees = sameFileCallee ? [] : await repo.queryRaw(
+        "SELECT id FROM graph_nodes WHERE type = ? AND label = ? LIMIT 2",
+        ["symbol", callExpression.calleeName]
+      );
+      const calleeNodeId = sameFileCallee ?? (globalCallees.length === 1 ? String(globalCallees[0].id) : void 0);
       if (!callerNodeId || !calleeNodeId || callerNodeId === calleeNodeId) continue;
       const edgeKey = `${callerNodeId}:${calleeNodeId}:calls`;
       if (insertedCallEdges.has(edgeKey)) continue;
@@ -319493,6 +319827,7 @@ function getRecentGraphRuns(rootPath, limit2 = 5) {
 function getWorkspaceGraphOptimized(rootPath, maxNodes, maxEdges) {
   const db = getWorkspaceDb2(rootPath);
   const countStmt = db.prepare("SELECT COUNT(*) AS count FROM graph_nodes");
+  const edgeCountStmt = db.prepare("SELECT COUNT(*) AS count FROM graph_edges");
   const nodesStmt = db.prepare(`
     SELECT * FROM graph_nodes
     ORDER BY
@@ -319500,12 +319835,31 @@ function getWorkspaceGraphOptimized(rootPath, maxNodes, maxEdges) {
       created_at DESC
     LIMIT ?
   `);
-  const edgesStmt = db.prepare("SELECT * FROM graph_edges LIMIT ?");
+  const edgesStmt = db.prepare(`
+    SELECT ge.* FROM graph_edges ge
+    WHERE ge.from_node_id IN (
+      SELECT id FROM graph_nodes
+      ORDER BY
+        CASE type ${typeOrderCase} ELSE 999 END,
+        created_at DESC
+      LIMIT ?
+    )
+    AND ge.to_node_id IN (
+      SELECT id FROM graph_nodes
+      ORDER BY
+        CASE type ${typeOrderCase} ELSE 999 END,
+        created_at DESC
+      LIMIT ?
+    )
+    LIMIT ?
+  `);
   const countResult = countStmt.get();
+  const edgeCountResult = edgeCountStmt.get();
   const nodeRows = nodesStmt.all(maxNodes);
-  const edgeRows = edgesStmt.all(maxEdges);
+  const edgeRows = edgesStmt.all(maxNodes, maxNodes, maxEdges);
   return {
     totalNodeCount: countResult.count,
+    totalEdgeCount: edgeCountResult.count,
     nodes: nodeRows.map((row) => ({
       id: String(row.id),
       label: String(row.label),
@@ -319883,10 +320237,12 @@ var init_server3 = __esm({
       const id = c.req.param("id");
       const workspace = getRegistryWorkspace(id);
       if (!workspace) return c.json(null);
-      const { nodes: nodeRows, edges: edgeRows } = getWorkspaceGraphOptimized(
+      const maxNodes = Math.min(parseInt(c.req.query("limit") ?? "25000", 10) || 25e3, 25e3);
+      const maxEdges = Math.min(parseInt(c.req.query("edgeLimit") ?? "75000", 10) || 75e3, 75e3);
+      const { nodes: nodeRows, edges: edgeRows, totalNodeCount, totalEdgeCount } = getWorkspaceGraphOptimized(
         workspace.rootPath,
-        300,
-        1e3
+        maxNodes,
+        maxEdges
       );
       const degreeMap = /* @__PURE__ */ new Map();
       for (const edge of edgeRows) {
@@ -319921,8 +320277,10 @@ var init_server3 = __esm({
         edges,
         nodeTypes,
         edgeTypes,
-        totalNodes: nodes.length,
-        totalEdges: edges.length
+        totalNodes: totalNodeCount,
+        totalEdges: totalEdgeCount,
+        displayedNodes: nodes.length,
+        displayedEdges: edges.length
       });
     });
     app.post("/api/query", async (c) => {
@@ -320128,7 +320486,7 @@ ${codeblock}`, options);
 });
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js
-function isEscaped(str2, ptr) {
+function isEscaped2(str2, ptr) {
   let i = 0;
   while (str2[ptr - ++i] === "\\")
     ;
@@ -320193,7 +320551,7 @@ function getStringEnd(str2, seek) {
   seek += target.length - 1;
   do
     seek = str2.indexOf(target, ++seek);
-  while (seek > -1 && first !== "'" && isEscaped(str2, seek));
+  while (seek > -1 && first !== "'" && isEscaped2(str2, seek));
   if (seek > -1) {
     seek += target.length;
     if (target.length > 1) {
@@ -321325,8 +321683,9 @@ var {
 // src/cli.ts
 init_src();
 init_src4();
+var pkg = JSON.parse(import_node_fs17.default.readFileSync(import_node_path21.default.resolve(__dirname, "../package.json"), "utf-8"));
 var program2 = new Command();
-program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version("0.4.0");
+program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version(pkg.version);
 program2.command("init").description("Initialize a workspace at the given path and run initial index").argument("[path]", "path to the project directory", process.cwd()).option("--no-index", "skip initial indexing").action(async (targetPath, options) => {
   const resolvedPath = import_node_path21.default.resolve(targetPath);
   if (!import_node_fs17.default.existsSync(resolvedPath)) {