codeui-python 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

codeui/lang/registry.py

@@ -6,6 +6,15 @@ from codeui.lang.python import PythonLanguageAnalyzer
 from codeui.lang.ts import TSLanguageAnalyzer
 from codeui.lang.go import GoLanguageAnalyzer
 from codeui.lang.rust import RustLanguageAnalyzer
+from codeui.lang.java import JavaLanguageAnalyzer
+from codeui.lang.cpp import CppLanguageAnalyzer
+from codeui.lang.csharp import CSharpLanguageAnalyzer
+from codeui.lang.php import PHPLanguageAnalyzer
+from codeui.lang.ruby import RubyLanguageAnalyzer
+from codeui.lang.kotlin import KotlinLanguageAnalyzer
+from codeui.lang.swift import SwiftLanguageAnalyzer
+from codeui.lang.scala import ScalaLanguageAnalyzer
+from codeui.lang.dart import DartLanguageAnalyzer
 from codeui.lang.generic import GenericLanguageAnalyzer
 
 class LanguageRegistry:
@@ -22,10 +31,19 @@ class LanguageRegistry:
             TSLanguageAnalyzer(),
             GoLanguageAnalyzer(),
             RustLanguageAnalyzer(),
+            JavaLanguageAnalyzer(),
+            CppLanguageAnalyzer(),
+            CSharpLanguageAnalyzer(),
+            PHPLanguageAnalyzer(),
+            RubyLanguageAnalyzer(),
+            KotlinLanguageAnalyzer(),
+            SwiftLanguageAnalyzer(),
+            ScalaLanguageAnalyzer(),
+            DartLanguageAnalyzer(),
             GenericLanguageAnalyzer(),
         ]
         self._ext_map: Dict[str, LanguageAnalyzer] = {}
-        for analyzer in self._analyzers:
+        for analyzer in reversed(self._analyzers):
             for ext in analyzer.extensions:
                 self._ext_map[ext.lower()] = analyzer
 
@@ -37,7 +55,9 @@ class LanguageRegistry:
         """
         self._analyzers.append(analyzer)
         for ext in analyzer.extensions:
-            self._ext_map[ext.lower()] = analyzer
+            ext_lower = ext.lower()
+            if type(analyzer).__name__ != "GenericLanguageAnalyzer" or ext_lower not in self._ext_map:
+                self._ext_map[ext_lower] = analyzer
 
     def get_analyzer(self, path: Path) -> LanguageAnalyzer:
         """Find language analyzer matching file extension or filename.

codeui/lang/ruby.py

@@ -0,0 +1,270 @@
+"""Ruby language analyzer for codeui."""
+from __future__ import annotations
+import hashlib
+import re
+from pathlib import Path
+from typing import ClassVar, Iterable, List, Sequence, TYPE_CHECKING
+from codeui.core.ir import Edge, EdgeKind, Location, Symbol, SymbolKind, Visibility
+from codeui.lang.base import ImportRef, LanguageAnalyzer, ParseResult
+
+if TYPE_CHECKING:
+    from codeui.core.resolver import ResolveContext
+
+class RubyLanguageAnalyzer(LanguageAnalyzer):
+    """Ruby language analyzer.
+    Example:
+        >>> analyzer = RubyLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("app.rb"), 'class App < Base\\n  def run\\n  end\\nend')
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.name == "App" for s in syms)
+        True
+    """
+    language: ClassVar[str] = "ruby"
+    extensions: ClassVar[tuple[str, ...]] = (".rb",)
+    has_ast_support: ClassVar[bool] = True
+    is_supported: ClassVar[bool] = True
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse Ruby source code into ParseResult.
+        Example:
+            >>> analyzer = RubyLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("main.rb"), "require 'json'")
+            >>> res.errors
+            []
+        """
+        content_hash = hashlib.sha256(source.encode("utf-8")).hexdigest()
+        return ParseResult(
+            file_path=str(path),
+            source=source,
+            ast=source,
+            content_hash=content_hash,
+            errors=[],
+        )
+
+    def extract_symbols(self, parse: ParseResult) -> Iterable[Symbol]:
+        """Extract modules, classes, and methods from Ruby source.
+        Example:
+            >>> analyzer = RubyLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("user.rb"), "class User\\n  def name\\n  end\\nend")
+            >>> syms = list(analyzer.extract_symbols(res))
+            >>> len(syms) >= 2
+            True
+        """
+        source = parse.source
+        file_path = parse.file_path
+        lines = source.splitlines()
+        max_line = len(lines) if lines else 1
+        symbols: List[Symbol] = []
+
+        file_sym = Symbol(
+            id=file_path,
+            name=Path(file_path).name,
+            qualified_name=file_path,
+            kind=SymbolKind.FILE,
+            language=self.language,
+            location=Location(file_path, 1, 0, max_line, 0),
+            parent_id=None,
+            signature=None,
+            visibility=Visibility.PUBLIC,
+            modifiers=(),
+            content_hash=parse.content_hash,
+        )
+        symbols.append(file_sym)
+
+        require_pattern = re.compile(r'require(?:_relative)?\s+["\']([^"\']+)["\']')
+        class_pattern = re.compile(r'(?:class|module)\s+([A-Za-z0-9_:]+)(?:\s*<\s*([A-Za-z0-9_:]+))?')
+        def_pattern = re.compile(r'def\s+(?:self\.)?([A-Za-z0-9_?!]+)(?:\s*\(([^)]*)\))?')
+
+        ruby_keywords = {"if", "for", "while", "unless", "until", "case", "when", "then", "begin", "rescue", "ensure", "end", "return", "class", "module", "def"}
+        class_ranges: List[tuple[str, str, int, int, str]] = []
+
+        for idx, line in enumerate(lines, start=1):
+            line_str = line.strip()
+            if not line_str or line_str.startswith("#"):
+                continue
+
+            for match in require_pattern.finditer(line_str):
+                req_path = match.group(1)
+                sym_id = f"import:{req_path}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=req_path.split("/")[-1],
+                    qualified_name=f"import:{req_path}",
+                    kind=SymbolKind.IMPORT,
+                    language=self.language,
+                    location=Location(file_path, idx, line.find(req_path), idx, line.find(req_path) + len(req_path)),
+                    parent_id=file_path,
+                    signature=f"require '{req_path}'",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=self._extract_body_hash(lines, idx - 1),
+                ))
+
+            for match in class_pattern.finditer(line_str):
+                cls_name = match.group(1)
+                if cls_name in ruby_keywords:
+                    continue
+                base_name = match.group(2) or ""
+                sym_id = f"{file_path}::{cls_name}"
+                end_line = self._find_ruby_block_end(lines, idx - 1)
+                class_ranges.append((cls_name, sym_id, idx, end_line, base_name))
+                loc = Location(file_path, idx, line.find(cls_name), end_line, line.find(cls_name) + len(cls_name))
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=cls_name,
+                    qualified_name=cls_name,
+                    kind=SymbolKind.CLASS,
+                    language=self.language,
+                    location=loc,
+                    parent_id=file_path,
+                    signature=f"class {cls_name}",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=self._extract_body_hash(lines, idx - 1),
+                ))
+
+            for match in def_pattern.finditer(line_str):
+                m_name = match.group(1)
+                params = match.group(2) or ""
+                if m_name in ruby_keywords:
+                    continue
+                enclosing = next((c for c in reversed(class_ranges) if c[2] <= idx <= c[3]), None)
+                if enclosing:
+                    cls_name, cls_sym_id, _, _, _ = enclosing
+                    sym_id = f"{file_path}::{cls_name}::{m_name}"
+                    qual_name = f"{cls_name}#{m_name}"
+                    parent_sym_id = cls_sym_id
+                    sym_kind = SymbolKind.METHOD
+                else:
+                    sym_id = f"{file_path}::{m_name}"
+                    qual_name = m_name
+                    parent_sym_id = file_path
+                    sym_kind = SymbolKind.FUNCTION
+                end_line = self._find_ruby_block_end(lines, idx - 1)
+                loc = Location(file_path, idx, line.find(m_name), end_line, line.find(m_name) + len(m_name))
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=m_name,
+                    qualified_name=qual_name,
+                    kind=sym_kind,
+                    language=self.language,
+                    location=loc,
+                    parent_id=parent_sym_id,
+                    signature=f"def {m_name}({params})",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=self._extract_body_hash(lines, idx - 1),
+                ))
+
+        return symbols
+
+    def extract_edges(self, parse: ParseResult, symbols: Sequence[Symbol]) -> Iterable[Edge]:
+        """Extract relationship edges for Ruby AST.
+        Example:
+            >>> analyzer = RubyLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("app.rb"), "require 'helper'")
+            >>> syms = list(analyzer.extract_symbols(res))
+            >>> edges = list(analyzer.extract_edges(res, syms))
+            >>> len(edges) >= 1
+            True
+        """
+        edges: List[Edge] = []
+        file_path = parse.file_path
+        sym_map = {s.id: s for s in symbols}
+        class_pattern = re.compile(r'class\s+([A-Za-z0-9_:]+)(?:\s*<\s*([A-Za-z0-9_:]+))?')
+        call_pattern = re.compile(r'(?<![A-Za-z0-9_$-])\b([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(|\s+[A-Za-z0-9_:"\'])')
+        ruby_keywords = {"if", "for", "while", "unless", "until", "case", "when", "then", "begin", "rescue", "ensure", "end", "return", "class", "module", "def", "puts", "print"}
+
+        for s in symbols:
+            if s.parent_id and s.parent_id in sym_map:
+                edges.append(Edge(
+                    source_id=s.parent_id,
+                    target_id=s.id,
+                    kind=EdgeKind.CONTAINS,
+                    weight=1.0,
+                    confidence=1.0,
+                    location=s.location,
+                ))
+            if s.kind == SymbolKind.IMPORT:
+                target_mod = s.qualified_name.replace("import:", "")
+                edges.append(Edge(
+                    source_id=file_path,
+                    target_id=f"module::{target_mod}",
+                    kind=EdgeKind.IMPORTS,
+                    weight=1.0,
+                    confidence=1.0,
+                    location=s.location,
+                ))
+
+        lines = parse.source.splitlines()
+        for idx, line in enumerate(lines, start=1):
+            line_str = line.strip()
+            if not line_str or line_str.startswith("#"):
+                continue
+            for match in class_pattern.finditer(line_str):
+                cls_name = match.group(1)
+                base_name = match.group(2)
+                if base_name and base_name not in ruby_keywords:
+                    cls_sym_id = f"{file_path}::{cls_name}"
+                    loc = Location(file_path, idx, line.find(base_name), idx, line.find(base_name) + len(base_name))
+                    edges.append(Edge(
+                        source_id=cls_sym_id,
+                        target_id=f"module::{base_name}",
+                        kind=EdgeKind.INHERITS,
+                        weight=1.0,
+                        confidence=0.9,
+                        location=loc,
+                    ))
+
+        func_syms = [s for s in symbols if s.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD)]
+        name_to_syms: dict[str, list[Symbol]] = {}
+        for s in func_syms:
+            name_to_syms.setdefault(s.name, []).append(s)
+
+        for f in func_syms:
+            if not f.location:
+                continue
+            f_lines = lines[f.location.start_line - 1 : f.location.end_line]
+            for f_line in f_lines:
+                for match in call_pattern.finditer(f_line):
+                    callee_name = match.group(1)
+                    if callee_name in ruby_keywords or callee_name == f.name:
+                        continue
+                    if callee_name in name_to_syms:
+                        target = name_to_syms[callee_name][0]
+                        edges.append(Edge(
+                            source_id=f.id,
+                            target_id=target.id,
+                            kind=EdgeKind.CALLS,
+                            weight=1.0,
+                            confidence=0.85,
+                            location=f.location,
+                        ))
+
+        return edges
+
+    def resolve_import(self, ref: ImportRef, ctx: ResolveContext) -> Iterable[str]:
+        """Resolve Ruby require references to project files.
+        Example:
+            >>> analyzer = RubyLanguageAnalyzer()
+            >>> ctx = ResolveContext(Path("."))
+            >>> list(analyzer.resolve_import(ImportRef("app.rb", "helper", None, False), ctx))
+            []
+        """
+        clean_path = ref.module_name.replace(".", "/")
+        return ctx.resolve_path(ref.file_path, clean_path, self.language)
+
+    def _find_ruby_block_end(self, lines: List[str], start_idx: int) -> int:
+        nesting = 0
+        block_starters = ("def ", "class ", "module ", "if ", "unless ", "case ", "while ", "until ", "for ", "begin ", "do ")
+        for i in range(start_idx, len(lines)):
+            l = lines[i].strip()
+            if not l or l.startswith("#"):
+                continue
+            if any(l.startswith(bs) for bs in block_starters) or l == "do":
+                nesting += 1
+            if l == "end" or l.startswith("end ") or l.endswith(" end"):
+                nesting -= 1
+                if nesting <= 0:
+                    return i + 1
+        return min(start_idx + 30, len(lines))

codeui/lang/rust.py

@@ -1,12 +1,15 @@
 """Rust language adapter for codeui."""
+from __future__ import annotations
 import hashlib
 import re
 from pathlib import Path
-from typing import ClassVar, Iterable, List, Sequence
+from typing import ClassVar, Iterable, List, Sequence, TYPE_CHECKING
 from codeui.core.ir import Edge, EdgeKind, Location, Symbol, SymbolKind, Visibility
-from codeui.core.resolver import ResolveContext
 from codeui.lang.base import ImportRef, LanguageAnalyzer, ParseResult
 
+if TYPE_CHECKING:
+    from codeui.core.resolver import ResolveContext
+
 class RustLanguageAnalyzer(LanguageAnalyzer):
     """Rust language analyzer.
     Example:

codeui/lang/scala.py

@@ -0,0 +1,290 @@
+"""Scala language adapter for codeui."""
+from __future__ import annotations
+import hashlib
+import re
+from pathlib import Path
+from typing import ClassVar, Iterable, List, Sequence, TYPE_CHECKING
+from codeui.core.ir import Edge, EdgeKind, Location, Symbol, SymbolKind, Visibility
+from codeui.lang.base import ImportRef, LanguageAnalyzer, ParseResult
+
+if TYPE_CHECKING:
+    from codeui.core.resolver import ResolveContext
+
+class ScalaLanguageAnalyzer(LanguageAnalyzer):
+    """Scala language adapter extracting traits, objects, case classes, defs, and vals.
+    Example:
+        >>> analyzer = ScalaLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("App.scala"), "case class User(id: Long, name: String)")
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.kind == SymbolKind.CLASS for s in syms)
+        True
+    """
+    language: ClassVar[str] = "scala"
+    extensions: ClassVar[tuple[str, ...]] = (".scala", ".sc")
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse Scala source into AST-emulating representation.
+        Example:
+            >>> analyzer = ScalaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("Main.scala"), "object Main extends App {}")
+            >>> res.errors
+            []
+        """
+        content_hash = hashlib.sha256(source.encode("utf-8")).hexdigest()
+        return ParseResult(
+            file_path=str(path),
+            source=source,
+            ast=source,
+            content_hash=content_hash,
+            errors=[],
+        )
+
+    def extract_symbols(self, parse: ParseResult) -> Iterable[Symbol]:
+        """Extract Scala packages, classes, traits, objects, defs, and vals.
+        Example:
+            >>> analyzer = ScalaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("Service.scala"), "trait Service { def run(): Unit }")
+            >>> syms = list(analyzer.extract_symbols(res))
+            >>> len(syms) >= 2
+            True
+        """
+        source = parse.source
+        file_path = parse.file_path
+        lines = source.splitlines()
+        max_line = len(lines) if lines else 1
+        symbols: List[Symbol] = []
+
+        file_sym = Symbol(
+            id=file_path,
+            name=Path(file_path).name,
+            qualified_name=file_path,
+            kind=SymbolKind.FILE,
+            language=self.language,
+            location=Location(file_path, 1, 0, max_line, 0),
+            parent_id=None,
+            signature=None,
+            visibility=Visibility.PUBLIC,
+            modifiers=(),
+            content_hash=parse.content_hash,
+        )
+        symbols.append(file_sym)
+
+        package_pattern = re.compile(r'^\s*package\s+([a-zA-Z0-9_.]+)')
+        import_pattern = re.compile(r'^\s*import\s+([a-zA-Z0-9_.*{}]+)')
+        type_pattern = re.compile(r'^\s*(?:(private|protected)(?:\[[a-zA-Z0-9_]+\])?\s+)?(?:(sealed|abstract|final|case|implicit|lazy)\s+)*(class|trait|object|enum)\s+([a-zA-Z0-9_]+)(?:\[[^\]]+\])?(?:\s*\([^)]*\))?(?:\s+extends\s+([a-zA-Z0-9_.,\s\[\]()]+))?(?:\s+with\s+([a-zA-Z0-9_.,\s\[\]()]+))?')
+        def_pattern = re.compile(r'^\s*(?:(private|protected)(?:\[[a-zA-Z0-9_]+\])?\s+)?(?:(override|final|implicit|def)\s+)*def\s+([a-zA-Z0-9_=+<>*/&|~^%-]+)(?:\[[^\]]+\])?\s*(?:\(([^)]*)\))?(?:\s*:\s*([a-zA-Z0-9_?<>,\s\[\]]+))?')
+        val_pattern = re.compile(r'^\s*(?:(private|protected)(?:\[[a-zA-Z0-9_]+\])?\s+)?(?:(override|final|implicit|lazy)\s+)*(val|var)\s+([a-zA-Z0-9_]+)(?:\s*:\s*([a-zA-Z0-9_?<>,\s\[\]]+))?')
+
+        current_package = ""
+        current_type: str | None = None
+        brace_depth = 0
+        type_depth = 0
+
+        for line_idx, line in enumerate(lines, start=1):
+            stripped = line.strip()
+            if not stripped or stripped.startswith("//") or stripped.startswith("/*") or stripped.startswith("*"):
+                continue
+
+            pkg_match = package_pattern.match(line)
+            if pkg_match:
+                current_package = pkg_match.group(1)
+                symbols.append(Symbol(
+                    id=f"{file_path}::package::{current_package}",
+                    name=current_package,
+                    qualified_name=current_package,
+                    kind=SymbolKind.NAMESPACE,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=file_path,
+                    signature=f"package {current_package}",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+                continue
+
+            imp_match = import_pattern.match(line)
+            if imp_match:
+                imp_name = imp_match.group(1)
+                symbols.append(Symbol(
+                    id=f"{file_path}::import::{imp_name}",
+                    name=imp_name.split(".")[-1],
+                    qualified_name=imp_name,
+                    kind=SymbolKind.IMPORT,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=file_path,
+                    signature=f"import {imp_name}",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+                continue
+
+            type_match = type_pattern.match(line)
+            if type_match:
+                vis_str = type_match.group(1) or "public"
+                mod_str = type_match.group(2)
+                type_kind = type_match.group(3)
+                type_name = type_match.group(4)
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str == "protected" else Visibility.PUBLIC)
+                kind = SymbolKind.INTERFACE if type_kind == "trait" else SymbolKind.CLASS
+                modifiers = tuple(filter(None, [mod_str, type_kind]))
+                qual_prefix = f"{current_package}." if current_package else ""
+                sym_id = f"{file_path}::{type_name}"
+                current_type = sym_id
+                type_depth = brace_depth
+
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=type_name,
+                    qualified_name=f"{qual_prefix}{type_name}",
+                    kind=kind,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=file_path,
+                    signature=f"{vis_str} {type_kind} {type_name}",
+                    visibility=vis,
+                    modifiers=modifiers,
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            def_match = def_pattern.match(line)
+            if def_match:
+                vis_str = def_match.group(1) or "public"
+                def_mod = def_match.group(2)
+                def_name = def_match.group(3)
+                def_args = def_match.group(4) or ""
+                def_ret = def_match.group(5) or "Unit"
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str == "protected" else Visibility.PUBLIC)
+                parent_id = current_type if current_type and brace_depth > type_depth else file_path
+                sym_id = f"{parent_id}::{def_name}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=def_name,
+                    qualified_name=f"{current_package}.{def_name}" if current_package else def_name,
+                    kind=SymbolKind.FUNCTION,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=parent_id,
+                    signature=f"def {def_name}({def_args}): {def_ret}",
+                    visibility=vis,
+                    modifiers=tuple(filter(None, [def_mod])),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            val_match = val_pattern.match(line)
+            if val_match:
+                vis_str = val_match.group(1) or "public"
+                val_mod = val_match.group(2)
+                val_or_var = val_match.group(3)
+                val_name = val_match.group(4)
+                val_type = val_match.group(5) or "Any"
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str == "protected" else Visibility.PUBLIC)
+                parent_id = current_type if current_type and brace_depth > type_depth else file_path
+                sym_id = f"{parent_id}::{val_name}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=val_name,
+                    qualified_name=f"{current_package}.{val_name}" if current_package else val_name,
+                    kind=SymbolKind.VARIABLE,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=parent_id,
+                    signature=f"{val_or_var} {val_name}: {val_type}",
+                    visibility=vis,
+                    modifiers=tuple(filter(None, [val_mod, val_or_var])),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            brace_depth += line.count("{") - line.count("}")
+            if current_type and brace_depth <= type_depth:
+                current_type = None
+
+        return sorted(symbols, key=lambda s: (s.location.start_line if s.location else 0, s.name))
+
+    def extract_edges(self, parse: ParseResult, symbols: Sequence[Symbol]) -> Iterable[Edge]:
+        """Extract containment, inheritance, and import edges for Scala.
+        Example:
+            >>> analyzer = ScalaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.scala"), "class Child extends Parent with TraitA")
+            >>> syms = list(analyzer.extract_symbols(res))
+            >>> edges = list(analyzer.extract_edges(res, syms))
+            >>> len(edges) >= 1
+            True
+        """
+        edges: List[Edge] = []
+        file_path = parse.file_path
+        symbol_map = {s.name: s for s in symbols}
+        type_inherit_pattern = re.compile(r'^\s*(?:[a-zA-Z0-9_\s<>]+)?(?:class|trait|object)\s+([a-zA-Z0-9_]+)(?:\[[^\]]+\])?(?:\s*\([^)]*\))?(?:\s+extends\s+([a-zA-Z0-9_.,\s\[\]()]+))?(?:\s+with\s+([a-zA-Z0-9_.,\s\[\]()]+))?')
+
+        for s in symbols:
+            if s.parent_id and s.parent_id != s.id:
+                edges.append(Edge(
+                    source_id=s.parent_id,
+                    target_id=s.id,
+                    kind=EdgeKind.CONTAINS,
+                    weight=1.0,
+                    confidence=1.0,
+                    location=s.location,
+                ))
+
+        for line_idx, line in enumerate(parse.source.splitlines(), start=1):
+            type_match = type_inherit_pattern.match(line)
+            if type_match:
+                type_name = type_match.group(1)
+                extends_raw = type_match.group(2)
+                with_raw = type_match.group(3)
+                type_sym = symbol_map.get(type_name)
+                if type_sym:
+                    super_candidates = []
+                    if extends_raw:
+                        super_candidates.append(extends_raw.strip().split("(")[0].split("[")[0].strip())
+                    if with_raw:
+                        for w in with_raw.split("with"):
+                            clean_w = w.strip().split("(")[0].split("[")[0].strip()
+                            if clean_w:
+                                super_candidates.append(clean_w)
+                    for sup in super_candidates:
+                        if sup and sup not in ("App", "Any", "Serializable", "Product"):
+                            target_id = symbol_map[sup].id if sup in symbol_map else sup
+                            edges.append(Edge(
+                                source_id=type_sym.id,
+                                target_id=target_id,
+                                kind=EdgeKind.INHERITS,
+                                weight=1.0,
+                                confidence=0.9,
+                                location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                            ))
+
+            if line.strip().startswith("import "):
+                imp_parts = line.strip().replace("import ", "").rstrip(";").split()
+                if imp_parts:
+                    target_mod = imp_parts[0].rstrip("._")
+                    edges.append(Edge(
+                        source_id=file_path,
+                        target_id=target_mod,
+                        kind=EdgeKind.IMPORTS,
+                        weight=1.0,
+                        confidence=1.0,
+                        location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    ))
+
+        return sorted(edges, key=lambda e: (e.source_id, e.target_id, e.kind.value))
+
+    def resolve_import(self, ref: ImportRef, ctx: ResolveContext) -> Iterable[str]:
+        """Resolve Scala package or object imports against project files.
+        Example:
+            >>> analyzer = ScalaLanguageAnalyzer()
+            >>> from codeui.core.resolver import ResolveContext
+            >>> ctx = ResolveContext(Path("."))
+            >>> ref = ImportRef("src/Main.scala", "com.example.Service", None, False)
+            >>> list(analyzer.resolve_import(ref, ctx))
+            []
+        """
+        mod_name = ref.module_name.rstrip("._")
+        candidates = ctx.resolve_path(ref.from_file, mod_name, "scala")
+        if not candidates and "." in mod_name:
+            leaf = mod_name.split(".")[-1]
+            candidates = ctx.resolve_path(ref.from_file, leaf, "scala")
+        return candidates