@openez-graph/cli 1.2.0 → 1.3.0

package/README.md

@@ -9,12 +9,12 @@ OpenEZ Graph indexes your codebase into a local SQLite database, builds a code g
 
 **Zero config. No Docker. No Postgres. No Redis. Just install and go.**
 
-> **v1.0: Bun-powered, Rust-native parsing.** The CLI now runs exclusively on [Bun](https://bun.sh) 1.1+ with native `bun:sqlite` (no `better-sqlite3` compilation step). TS/JS parsing uses [oxc-parser](https://oxc.rs) (Rust-based, ~13x faster than Babel) instead of `ts-morph`. Python/Go/Rust use tree-sitter in rayon-parallel batches. Requires Bun 1.1+.
+> **v1.0: Bun-powered, Rust-native parsing.** The CLI now runs exclusively on [Bun](https://bun.sh) 1.1+ with native `bun:sqlite` (no `better-sqlite3` compilation step). TS/JS parsing uses [oxc-parser](https://oxc.rs) (Rust-based, ~13x faster than Babel) instead of `ts-morph`. Python/Go/Rust/Ruby use tree-sitter (WASM) with regex fallback. Requires Bun 1.1+.
 
 ## Features
 
 - **Bun-powered** — native `bun:sqlite` driver, no native compilation, near-instant startup
-- **Rust-native parsing** — [oxc-parser](https://oxc.rs) for TS/JS (~13x faster than Babel), tree-sitter for Python/Go/Rust in rayon-parallel batches
+- **Rust-native parsing** — [oxc-parser](https://oxc.rs) for TS/JS (~13x faster than Babel), tree-sitter (WASM) for Python/Go/Rust/Ruby with regex fallback
 - **Zero-config** — auto-registers workspace, auto-indexes; opt-in auto-sync via `OPENEZ_MCP_WATCH=1`
 - **SQLite-first** — all data stored locally in `.openez/` per workspace, no Postgres/Redis
 - **FTS5 full-text search** — SQLite FTS5 with BM25 ranking and porter tokenizer
@@ -106,14 +106,16 @@ Valid config keys: `embedding.provider`, `embedding.openai_api_key`, `embedding.
 
 ## Supported languages
 
-| Language                | Parser                       | Indexing depth                                                       |
-| ----------------------- | ---------------------------- | -------------------------------------------------------------------- |
-| TypeScript / JavaScript | [oxc-parser](https://oxc.rs) | Richest — symbol extraction, imports, calls (~13x faster than Babel) |
-| Python                  | tree-sitter (Rust, rayon)    | Symbol extraction, decorators, imports, calls                        |
-| Go                      | tree-sitter (Rust, rayon)    | Symbol extraction, receiver-qualified methods, calls                 |
-| Rust                    | tree-sitter (Rust, rayon)    | Symbol extraction, impl blocks, calls                                |
-| YAML / JSON / TOML      | Structure-aware              | Structure-aware chunking                                             |
-| Markdown                | Section-oriented             | Section-oriented chunking                                            |
+| Language                                              | Parser                       | Indexing depth                                                                           |
+| ----------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------- |
+| TypeScript / JavaScript                               | [oxc-parser](https://oxc.rs) | Richest — symbol extraction, imports, calls (~13x faster than Babel)                     |
+| Python                                                | tree-sitter (WASM)           | Symbol extraction, decorators, imports, calls                                            |
+| Go                                                    | tree-sitter (WASM)           | Symbol extraction, receiver-qualified methods, calls                                     |
+| Rust                                                  | tree-sitter (WASM)           | Symbol extraction, impl blocks, calls                                                    |
+| Ruby                                                  | tree-sitter (WASM)           | Symbol extraction, `class << self` context, `self.foo` calls, `require_relative` imports |
+| CoffeeScript / Slim / CSS / SCSS / SASS / LESS / Haml | Fallback parser              | Scanned and chunked (no symbol extraction)                                               |
+| YAML / JSON / TOML                                    | Structure-aware              | Structure-aware chunking                                                                 |
+| Markdown                                              | Section-oriented             | Section-oriented chunking                                                                |
 
 ## Retrieval quality
 

package/dist/CHANGELOG.md

@@ -5,12 +5,26 @@ All notable changes to OpenEZ Graph are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-08-15
+
+### Added
+
+- **Ruby indexing** — tree-sitter WASM symbol extraction for classes, modules, methods, singleton methods, named lambdas, `class << self` nesting, and `require_relative` import edges.
+- **Ruby and frontend language scanning** — `.rb`, `.rake`, `.gemspec`, CoffeeScript, Slim, CSS, SCSS, Sass, Less, and Haml files are now indexed; unsupported languages use fallback chunking.
+
+### Fixed
+
+- **Ruby graph extraction** — preserves calls inside ordinary assignments, qualifies `self` calls in class bodies, keeps regex fallback nesting correct, and aligns method export metadata with the AST parser.
+
 ## [1.2.0] - 2026-08-11
 
 ### Added
 
 - **Lease-based indexing ownership** — indexing claims a 60-second lease with 15-second heartbeat. If the lease expires (e.g. process crash), another process can take over. Completion and failure writes are fenced by owner token — a stale owner cannot overwrite the status set by a newer owner.
 - **Graph build warnings in MCP** — `code_query` response includes a `warnings` array when graph expansion fails, so callers see FTS-only results instead of silently missing graph expansion.
+- **Web UI: Reindex button** — workspace detail page now has a "Reindex workspace" button with loading state and error display, triggering a full rebuild via `startIndexRun(workspaceId, "full")`.
+- **Web UI: Build & Open Graph** — workspace detail page shows "Build & Open Graph" button when graph data is empty, or "Open Graph" when graph exists. Graph is built lazily on first access via `ensureGraphReady`.
+- **Web UI: Local embedding model picker** — settings page now supports selecting local embedding model preset (`jina-code-static-256`) with server-side validation against `LOCAL_EMBEDDING_MODELS` catalog. Provider dropdown includes "OpenEZ local" option alongside OpenAI and Ollama.
 
 ### Fixed
 
@@ -286,6 +300,7 @@ Remediation release — index/graph correctness, data protection, and web flow f
 - CLI npm packaging
 
 [1.2.0]: https://github.com/asta-nguyen/openez-graph/compare/v1.1.0...v1.2.0
+[1.3.0]: https://github.com/asta-nguyen/openez-graph/compare/v1.2.0...v1.3.0
 [1.1.0]: https://github.com/asta-nguyen/openez-graph/compare/v1.0.3...v1.1.0
 [1.0.3]: https://github.com/asta-nguyen/openez-graph/compare/v1.0.2...v1.0.3
 [1.0.2]: https://github.com/asta-nguyen/openez-graph/compare/v1.0.1...v1.0.2

package/dist/cli.cjs

@@ -33034,6 +33034,15 @@ function inferDocumentKind(filePath) {
   if (codeExtensions.has(extension)) {
     return { kind: "code", language: codeExtensions.get(extension) ?? null, extension };
   }
+  if (styleExtensions.has(extension)) {
+    return { kind: "code", language: styleExtensions.get(extension) ?? null, extension };
+  }
+  if (templateExtensions.has(extension)) {
+    return { kind: "code", language: templateExtensions.get(extension) ?? null, extension };
+  }
+  if (scriptExtensions.has(extension)) {
+    return { kind: "code", language: scriptExtensions.get(extension) ?? null, extension };
+  }
   if (configExtensions.has(extension)) {
     return { kind: "config", language: configExtensions.get(extension) ?? null, extension };
   }
@@ -33537,6 +33546,83 @@ function parseRust(content, counter = exactTokenCounter) {
     callExpressions
   };
 }
+function findRubyBlockEnd(codeLines, startIndex) {
+  const openingLine = codeLines[startIndex] ?? "";
+  if (openingLine.includes(";") && /\bend\s*(?:#.*)?$/.test(openingLine)) {
+    return startIndex + 1;
+  }
+  const baseIndent = codeLines[startIndex]?.search(/\S/) ?? 0;
+  for (let i = startIndex + 1; i < codeLines.length; i++) {
+    const trimmed = codeLines[i].trim();
+    if (trimmed === "") continue;
+    const indent = codeLines[i].search(/\S/);
+    if (indent < 0) continue;
+    if (indent < baseIndent) {
+      return i;
+    }
+    if (indent === baseIndent && (trimmed === "end" || trimmed.startsWith("end ") || trimmed.startsWith("end	"))) {
+      return i + 1;
+    }
+  }
+  return codeLines.length;
+}
+function parseRuby(content, counter = exactTokenCounter) {
+  const lines = content.split("\n");
+  const codeLines = stripNonCode(content, { hashComments: true }).split("\n");
+  const definedSymbols = [];
+  const importPaths = [];
+  const calledIdentifiers = /* @__PURE__ */ new Set();
+  const callExpressions = [];
+  const symbolRegex = /^\s*(?:def\s+(?:self\.)?(\w+[?!]?)|class\s+(\w+(?:::\w+)*)|module\s+(\w+(?:::\w+)*))/;
+  const requireRelativeRegex = /\brequire_relative\s+['"]([^'"]+)['"]/g;
+  const contextStack = [];
+  for (let i = 0; i < codeLines.length; i++) {
+    const line = codeLines[i];
+    const trimmed = line.trim();
+    while (contextStack.length > 0 && i >= contextStack[contextStack.length - 1].endLine) {
+      contextStack.pop();
+    }
+    const match2 = symbolRegex.exec(trimmed);
+    if (match2) {
+      const rawName = match2[1] ?? match2[2] ?? match2[3];
+      if (!rawName) continue;
+      const isMethod = Boolean(match2[1]);
+      const symbolType2 = isMethod ? "function" : match2[2] ? "class" : "module";
+      const parentName = contextStack.length > 0 ? contextStack[contextStack.length - 1].name : null;
+      const name = parentName ? `${parentName}::${rawName}` : rawName;
+      const endLine = findRubyBlockEnd(codeLines, i);
+      definedSymbols.push({
+        name,
+        symbolType: symbolType2,
+        type: symbolType2,
+        exported: isMethod ? false : !rawName.startsWith("_"),
+        startLine: i + 1,
+        endLine
+      });
+      contextStack.push({ name, endLine });
+      continue;
+    }
+    requireRelativeRegex.lastIndex = 0;
+    let reqMatch;
+    while ((reqMatch = requireRelativeRegex.exec(lines[i] ?? "")) !== null) {
+      importPaths.push(reqMatch[1]);
+    }
+  }
+  const chunks2 = createSymbolChunks(definedSymbols, lines, "ruby", counter);
+  if (chunks2.length === 0) {
+    return {
+      ...makeFallbackChunks(content, lines, counter),
+      importPaths: [...new Set(importPaths)]
+    };
+  }
+  return {
+    chunks: chunks2,
+    importPaths: [...new Set(importPaths)],
+    definedSymbols,
+    calledIdentifiers: [...calledIdentifiers],
+    callExpressions
+  };
+}
 function indexConfig(content, language, counter = exactTokenCounter) {
   switch (language) {
     case "yaml":
@@ -33808,7 +33894,7 @@ function makeFallbackChunks(content, lines, counter = exactTokenCounter) {
     callExpressions: []
   };
 }
-var import_node_path11, codeExtensions, configExtensions, markdownExtensions, PYTHON_CALL_IGNORES, GO_CALL_IGNORES, RUST_CALL_IGNORES;
+var import_node_path11, codeExtensions, configExtensions, styleExtensions, templateExtensions, scriptExtensions, markdownExtensions, PYTHON_CALL_IGNORES, GO_CALL_IGNORES, RUST_CALL_IGNORES;
 var init_languages = __esm({
   "../../packages/indexer/src/languages.ts"() {
     "use strict";
@@ -33826,7 +33912,10 @@ var init_languages = __esm({
       [".cts", "typescript"],
       [".py", "python"],
       [".go", "go"],
-      [".rs", "rust"]
+      [".rs", "rust"],
+      [".rb", "ruby"],
+      [".rake", "ruby"],
+      [".gemspec", "ruby"]
     ]);
     configExtensions = /* @__PURE__ */ new Map([
       [".yaml", "yaml"],
@@ -33834,6 +33923,20 @@ var init_languages = __esm({
       [".json", "json"],
       [".toml", "toml"]
     ]);
+    styleExtensions = /* @__PURE__ */ new Map([
+      [".css", "css"],
+      [".scss", "scss"],
+      [".sass", "scss"],
+      [".less", "less"]
+    ]);
+    templateExtensions = /* @__PURE__ */ new Map([
+      [".slim", "slim"],
+      [".haml", "haml"]
+    ]);
+    scriptExtensions = /* @__PURE__ */ new Map([
+      [".coffee", "coffeescript"],
+      [".litcoffee", "coffeescript"]
+    ]);
     markdownExtensions = /* @__PURE__ */ new Set([".md", ".mdx"]);
     PYTHON_CALL_IGNORES = /* @__PURE__ */ new Set([
       "if",
@@ -34863,44 +34966,62 @@ function walkTree(root, config2, lines) {
     }
     const symbolRule = symbolRuleMap.get(node.type);
     if (symbolRule) {
-      const name = symbolRule.extractName ? symbolRule.extractName(node) : getNodeName(node, symbolRule.nameField);
-      if (name) {
-        const parentName = contextStack.length > 0 ? contextStack[contextStack.length - 1].name : null;
-        const exported = symbolRule.isExported ? symbolRule.isExported(name, node) : false;
-        let receiver;
-        let receiverVar = null;
-        let receiverType = null;
-        if (symbolRule.receiverField) {
-          const rawReceiver = node.childForFieldName(symbolRule.receiverField)?.text;
-          if (rawReceiver) {
-            receiver = symbolRule.normalizeReceiver ? symbolRule.normalizeReceiver(rawReceiver) : rawReceiver;
-            receiverVar = goReceiverName(rawReceiver);
-            receiverType = goReceiverType(rawReceiver);
-          }
-        }
-        const fullName = receiverType ? `${receiverType}::${name}` : parentName ? `${parentName}::${name}` : name;
-        symbols.push({
-          name: fullName,
-          symbolType: symbolRule.symbolType,
-          type: symbolRule.symbolType,
-          exported,
-          startLine: startRow,
-          endLine: endRow,
-          ...receiver ? { receiver } : {}
-        });
-        const receiverInfo = receiverVar && receiverType ? { varName: receiverVar, typeName: receiverType } : void 0;
-        extractCallsInNode(
-          node,
-          config2,
-          fullName,
-          receiverInfo,
-          calledIdentifiers,
-          callExpressions
-        );
-        const isContextNode = symbolRule.establishesContext || config2.contextNodeTypes.has(node.type);
-        if (isContextNode) {
-          const contextName = symbolRule.extractContextName ? symbolRule.extractContextName(node) ?? fullName : fullName;
-          contextStack.push({ name: contextName, endRow, receiver: receiverInfo });
+      if (symbolRule.contextOnly) {
+        const contextName = symbolRule.extractContextName ? symbolRule.extractContextName(node, contextStack) ?? null : null;
+        if (contextName) {
+          contextStack.push({
+            name: contextName,
+            endRow,
+            kind: symbolRule.contextKind
+          });
+        }
+      } else {
+        const name = symbolRule.extractName ? symbolRule.extractName(node) : getNodeName(node, symbolRule.nameField ?? "name");
+        if (name) {
+          const parentName = contextStack.length > 0 ? contextStack[contextStack.length - 1].name : null;
+          const exported = symbolRule.isExported ? symbolRule.isExported(name, node) : false;
+          let receiver;
+          let receiverVar = null;
+          let receiverType = null;
+          if (symbolRule.receiverField) {
+            const rawReceiver = node.childForFieldName(symbolRule.receiverField)?.text;
+            if (rawReceiver) {
+              receiver = symbolRule.normalizeReceiver ? symbolRule.normalizeReceiver(rawReceiver) : rawReceiver;
+              receiverVar = goReceiverName(rawReceiver);
+              receiverType = goReceiverType(rawReceiver);
+            }
+          }
+          const fullName = receiverType ? `${receiverType}::${name}` : parentName ? `${parentName}::${name}` : name;
+          symbols.push({
+            name: fullName,
+            symbolType: symbolRule.symbolType,
+            type: symbolRule.symbolType,
+            exported,
+            startLine: startRow,
+            endLine: endRow,
+            ...receiver ? { receiver } : {}
+          });
+          const receiverInfo = receiverVar && receiverType ? { varName: receiverVar, typeName: receiverType } : void 0;
+          const isContextNode = symbolRule.establishesContext || config2.contextNodeTypes.has(node.type);
+          const contextName = isContextNode ? symbolRule.extractContextName?.(node, contextStack) ?? fullName : null;
+          const callContext = contextName && symbolRule.contextKind ? [...contextStack, { name: contextName, endRow, kind: symbolRule.contextKind }] : contextStack;
+          extractCallsInNode(
+            node,
+            config2,
+            fullName,
+            receiverInfo,
+            calledIdentifiers,
+            callExpressions,
+            callContext
+          );
+          if (isContextNode) {
+            contextStack.push({
+              name: contextName ?? fullName,
+              endRow,
+              kind: symbolRule.contextKind,
+              receiver: receiverInfo
+            });
+          }
         }
       }
     } else if (isCallNode(node, config2.callRule)) {
@@ -34919,9 +35040,19 @@ function walkTree(root, config2, lines) {
   }
   return { symbols, importPaths, calledIdentifiers, callExpressions };
 }
-function extractCallsInNode(symbolNode, config2, callerName, receiverInfo, calledIdentifiers, callExpressions) {
-  const nestedSymbolTypes = config2.symbolRules.map((r) => r.nodeType);
-  const nestedSymbols = symbolNode.descendantsOfType(nestedSymbolTypes).filter((n) => !(n.startIndex === symbolNode.startIndex && n.endIndex === symbolNode.endIndex));
+function extractCallsInNode(symbolNode, config2, callerName, receiverInfo, calledIdentifiers, callExpressions, contextStack) {
+  const symbolRuleMap = new Map(config2.symbolRules.map((rule) => [rule.nodeType, rule]));
+  const nestedSymbols = symbolNode.descendantsOfType(config2.symbolRules.map((rule) => rule.nodeType)).filter((node) => {
+    if (node.startIndex === symbolNode.startIndex && node.endIndex === symbolNode.endIndex) {
+      return false;
+    }
+    const rule = symbolRuleMap.get(node.type);
+    if (!rule) return false;
+    if (rule.contextOnly) return true;
+    return Boolean(
+      rule.extractName ? rule.extractName(node) : getNodeName(node, rule.nameField ?? "name")
+    );
+  });
   const callNodes = symbolNode.descendantsOfType(config2.callRule.nodeType);
   for (const callNode of callNodes) {
     const insideNested = nestedSymbols.some(
@@ -34932,11 +35063,13 @@ function extractCallsInNode(symbolNode, config2, callerName, receiverInfo, calle
     if (!calleeName2) continue;
     const normalized = config2.normalizeCallName(calleeName2);
     const qualifiedCallee = receiverInfo && calleeName2.startsWith(`${receiverInfo.varName}.`) ? `${receiverInfo.typeName}::${normalized}` : normalized;
-    if (!normalized || config2.callIgnores.has(calleeName2) || config2.callIgnores.has(normalized) || qualifiedCallee === callerName) {
+    const hookQualified = config2.qualifyCall?.(callNode, calleeName2, normalized, contextStack);
+    const finalCallee = hookQualified ?? qualifiedCallee;
+    if (!normalized || config2.callIgnores.has(calleeName2) || config2.callIgnores.has(normalized) || finalCallee === callerName) {
       continue;
     }
-    calledIdentifiers.add(qualifiedCallee);
-    callExpressions.push({ callerName, calleeName: qualifiedCallee });
+    calledIdentifiers.add(finalCallee);
+    callExpressions.push({ callerName, calleeName: finalCallee });
   }
 }
 async function parseWithTreeSitter(config2, content, counter) {
@@ -35053,7 +35186,42 @@ function extractRustImports(node) {
   }
   return paths;
 }
-var PYTHON_CALL_IGNORES2, pythonConfig, GO_CALL_IGNORES2, goConfig, RUST_CALL_IGNORES2, rustConfig;
+function normalizeRubyCallName(value) {
+  const parts = value.split(/[.::]/).filter(Boolean);
+  return parts[parts.length - 1] ?? value;
+}
+function extractRubyImports(node) {
+  const paths = [];
+  if (node.type === "call") {
+    const methodNode = node.childForFieldName("method");
+    if (methodNode && methodNode.text === "require_relative") {
+      const argsNode = node.childForFieldName("arguments");
+      if (argsNode) {
+        const stringNode = argsNode.namedChildren.find(
+          (c) => c.type === "string" || c.type === "argument_list"
+        );
+        const target = stringNode?.type === "string" ? stringNode : stringNode?.namedChildren.find((c) => c.type === "string");
+        if (target) {
+          const text2 = target.text.replace(/^['"]|['"]$/g, "");
+          if (text2) paths.push(text2);
+        }
+      }
+    }
+  }
+  return paths;
+}
+function rubyQualifyCall(callNode, _calleeName, normalized, contextStack) {
+  const receiverNode = callNode.childForFieldName("receiver");
+  if (!receiverNode || receiverNode.text !== "self") return null;
+  for (let i = contextStack.length - 1; i >= 0; i--) {
+    const frame = contextStack[i];
+    if (frame.kind === "class" || frame.kind === "module") {
+      return `${frame.name}::${normalized}`;
+    }
+  }
+  return null;
+}
+var PYTHON_CALL_IGNORES2, pythonConfig, GO_CALL_IGNORES2, goConfig, RUST_CALL_IGNORES2, rustConfig, RUBY_CALL_IGNORES, rubyConfig;
 var init_configs = __esm({
   "../../packages/indexer/src/tree-sitter/configs.ts"() {
     "use strict";
@@ -35280,7 +35448,7 @@ var init_configs = __esm({
             }
             return typeName ? `impl ${typeName}` : null;
           },
-          extractContextName: (node) => {
+          extractContextName: (node, _contextStack) => {
             return node.childForFieldName("type")?.text ?? null;
           },
           establishesContext: true,
@@ -35318,6 +35486,132 @@ var init_configs = __esm({
       contextNodeTypes: /* @__PURE__ */ new Set(["function_item", "trait_item", "impl_item"]),
       contextNameField: "name"
     };
+    RUBY_CALL_IGNORES = /* @__PURE__ */ new Set([
+      "if",
+      "unless",
+      "while",
+      "until",
+      "for",
+      "return",
+      "yield",
+      "break",
+      "next",
+      "redo",
+      "retry",
+      "puts",
+      "pp",
+      "p",
+      "print",
+      "raise",
+      "require",
+      "require_relative",
+      "load",
+      "autoload",
+      "attr_accessor",
+      "attr_reader",
+      "attr_writer",
+      "include",
+      "extend",
+      "define_method",
+      "lambda",
+      "proc",
+      "super",
+      "self",
+      "nil",
+      "true",
+      "false",
+      "new",
+      "Array",
+      "Hash",
+      "String",
+      "Integer",
+      "Float",
+      "Symbol"
+    ]);
+    rubyConfig = {
+      language: "ruby",
+      symbolRules: [
+        {
+          nodeType: "class",
+          symbolType: "class",
+          nameField: "name",
+          establishesContext: true,
+          contextKind: "class",
+          isExported: (name) => name[0] >= "A" && name[0] <= "Z"
+        },
+        {
+          nodeType: "module",
+          symbolType: "module",
+          nameField: "name",
+          establishesContext: true,
+          contextKind: "module",
+          isExported: (name) => name[0] >= "A" && name[0] <= "Z"
+        },
+        {
+          nodeType: "method",
+          symbolType: "function",
+          nameField: "name",
+          establishesContext: true,
+          isExported: () => false
+        },
+        {
+          nodeType: "singleton_method",
+          symbolType: "function",
+          nameField: "name",
+          establishesContext: true,
+          isExported: () => false
+        },
+        {
+          nodeType: "singleton_class",
+          symbolType: "class",
+          contextOnly: true,
+          extractContextName: (_node, contextStack) => {
+            for (let i = contextStack.length - 1; i >= 0; i--) {
+              const frame = contextStack[i];
+              if (frame.kind === "class" || frame.kind === "module") {
+                return frame.name;
+              }
+            }
+            return null;
+          },
+          isExported: () => false
+        },
+        {
+          nodeType: "assignment",
+          symbolType: "lambda",
+          extractName: (node) => {
+            const rightNode = node.childForFieldName("right");
+            if (!rightNode) return null;
+            if (rightNode.type === "lambda") {
+              const leftNode = node.childForFieldName("left");
+              return leftNode?.text ?? null;
+            }
+            if (rightNode.type === "call") {
+              const methodNode = rightNode.childForFieldName("method");
+              const methodName = methodNode?.text;
+              if (methodName === "proc" || methodName === "lambda") {
+                const leftNode = node.childForFieldName("left");
+                return leftNode?.text ?? null;
+              }
+              const receiverNode = rightNode.childForFieldName("receiver");
+              if (receiverNode?.text === "Proc" && methodName === "new") {
+                const leftNode = node.childForFieldName("left");
+                return leftNode?.text ?? null;
+              }
+            }
+            return null;
+          },
+          isExported: () => false
+        }
+      ],
+      importRules: [{ nodeType: "call", extract: extractRubyImports }],
+      callRule: { nodeType: "call", functionField: "method" },
+      callIgnores: RUBY_CALL_IGNORES,
+      normalizeCallName: normalizeRubyCallName,
+      contextNodeTypes: /* @__PURE__ */ new Set(["class", "module", "method", "singleton_method"]),
+      contextNameField: "name",
+      qualifyCall: rubyQualifyCall
+    };
   }
 });
 
@@ -35345,12 +35639,14 @@ var init_tree_sitter_parser = __esm({
     LANGUAGE_CONFIGS = {
       python: pythonConfig,
       go: goConfig,
-      rust: rustConfig
+      rust: rustConfig,
+      ruby: rubyConfig
     };
     REGEX_FALLBACKS = {
       python: parsePython,
       go: parseGo,
-      rust: parseRust
+      rust: parseRust,
+      ruby: parseRuby
     };
     TreeSitterParser = class {
       name = "tree-sitter";
@@ -43052,12 +43348,18 @@ var init_scanner = __esm({
     DEFAULT_INCLUDE_PATTERNS = [
       ...Array.from(codeExtensions.keys()).map((ext) => `**/*${ext}`),
       ...Array.from(configExtensions.keys()).map((ext) => `**/*${ext}`),
-      ...Array.from(markdownExtensions).map((ext) => `**/*${ext}`)
+      ...Array.from(markdownExtensions).map((ext) => `**/*${ext}`),
+      ...Array.from(styleExtensions.keys()).map((ext) => `**/*${ext}`),
+      ...Array.from(templateExtensions.keys()).map((ext) => `**/*${ext}`),
+      ...Array.from(scriptExtensions.keys()).map((ext) => `**/*${ext}`)
     ];
     ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
       ...codeExtensions.keys(),
       ...configExtensions.keys(),
-      ...markdownExtensions
+      ...markdownExtensions,
+      ...styleExtensions.keys(),
+      ...templateExtensions.keys(),
+      ...scriptExtensions.keys()
     ]);
     DEFAULT_EXCLUDE_PATTERNS = [
       "**/node_modules",
@@ -43178,6 +43480,9 @@ function createWorkspaceFileResolver(workspaceRoot, files) {
         const resolved = resolvePythonImport(importerRelativePath, importPath);
         if (resolved) return resolved;
       }
+      if (language === "ruby") {
+        return resolveRelativeImport(importerRelativePath, importPath);
+      }
       if (importPath.startsWith(".")) {
         return resolveRelativeImport(importerRelativePath, importPath);
       }
@@ -44116,7 +44421,8 @@ var init_index_workspace = __esm({
       ".cts",
       ".md",
       ".mdx",
-      ".py"
+      ".py",
+      ".rb"
     ];
     PARSER_VERSION_OXC = "oxc-v2";
     PARSER_VERSION_NATIVE = "native-v1";
@@ -59961,7 +60267,7 @@ __export(mcp_bridge_exports, {
   startMcpServer: () => startMcpServer
 });
 async function startMcpServer(defaultPath, version4) {
-  await createAndStartMcpServer({ defaultPath, version: version4, build: "32a9b86-dirty" });
+  await createAndStartMcpServer({ defaultPath, version: version4, build: "dcb4ee5-dirty" });
 }
 var init_mcp_bridge = __esm({
   "src/mcp-bridge.ts"() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openez-graph/cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Local-first code intelligence engine — index, query, and graph your codebase with zero config. SQLite-only, MCP-first.",
   "license": "MIT",
   "author": "Asta Nguyen",
@@ -51,6 +51,7 @@
     "oxc-parser": "^0.143.0",
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-python": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1",
     "tree-sitter-rust": "^0.24.0",
     "web-tree-sitter": "^0.26.11"
   },