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

codeui/lang/dart.py

@@ -0,0 +1,278 @@
+"""Dart 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 DartLanguageAnalyzer(LanguageAnalyzer):
+    """Dart language adapter extracting classes, mixins, enums, functions, and properties.
+    Example:
+        >>> analyzer = DartLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("main.dart"), "class User { final int id; User(this.id); }")
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.kind == SymbolKind.CLASS for s in syms)
+        True
+    """
+    language: ClassVar[str] = "dart"
+    extensions: ClassVar[tuple[str, ...]] = (".dart",)
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse Dart source into AST-emulating representation.
+        Example:
+            >>> analyzer = DartLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("app.dart"), "void main() {}")
+            >>> 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 Dart types, functions, methods, properties, and imports.
+        Example:
+            >>> analyzer = DartLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("service.dart"), "class Service { Future<void> init() async {} }")
+            >>> 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)
+
+        import_pattern = re.compile(r'^\s*(?:import|export)\s+[\'"]([^\'"]+)[\'"](?:\s+as\s+([a-zA-Z0-9_]+))?')
+        type_pattern = re.compile(r'^\s*(?:(abstract|sealed|base|interface|final)\s+)?(class|mixin|enum|extension)\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([a-zA-Z0-9_.,\s<>]+))?(?:\s+with\s+([a-zA-Z0-9_.,\s<>]+))?(?:\s+implements\s+([a-zA-Z0-9_.,\s<>]+))?')
+        func_pattern = re.compile(r'^\s*(?:(static|override|factory)\s+)*(?:([a-zA-Z0-9_?<>]+)\s+)?([a-zA-Z0-9_]+)\s*\(([^)]*)\)(?:\s*async\s*)?(?:\s*\{|\s*=>)')
+        prop_pattern = re.compile(r'^\s*(?:(static|final|const|late)\s+)*(?:([a-zA-Z0-9_?<>]+)\s+)?([a-zA-Z0-9_]+)(?:\s*=\s*[^;]+)?\s*;')
+
+        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
+
+            imp_match = import_pattern.match(line)
+            if imp_match:
+                imp_uri = imp_match.group(1)
+                alias = imp_match.group(2) or imp_uri.split("/")[-1].replace(".dart", "")
+                symbols.append(Symbol(
+                    id=f"{file_path}::import::{imp_uri}",
+                    name=alias,
+                    qualified_name=imp_uri,
+                    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_uri}'",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=(),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+                continue
+
+            type_match = type_pattern.match(line)
+            if type_match:
+                mod_str = type_match.group(1)
+                type_kind = type_match.group(2)
+                type_name = type_match.group(3)
+                vis = Visibility.PRIVATE if type_name.startswith("_") else Visibility.PUBLIC
+                kind = SymbolKind.INTERFACE if type_kind in ("mixin", "interface") else SymbolKind.CLASS
+                modifiers = tuple(filter(None, [mod_str, type_kind]))
+                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=type_name,
+                    kind=kind,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=file_path,
+                    signature=f"{type_kind} {type_name}",
+                    visibility=vis,
+                    modifiers=modifiers,
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            func_match = func_pattern.match(line)
+            if func_match:
+                func_mod = func_match.group(1)
+                func_ret = func_match.group(2) or "void"
+                func_name = func_match.group(3)
+                func_args = func_match.group(4) or ""
+                if func_name not in ("if", "for", "while", "switch", "catch"):
+                    vis = Visibility.PRIVATE if func_name.startswith("_") else Visibility.PUBLIC
+                    parent_id = current_type if current_type and brace_depth > type_depth else file_path
+                    sym_id = f"{parent_id}::{func_name}"
+                    symbols.append(Symbol(
+                        id=sym_id,
+                        name=func_name,
+                        qualified_name=func_name,
+                        kind=SymbolKind.FUNCTION,
+                        language=self.language,
+                        location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                        parent_id=parent_id,
+                        signature=f"{func_ret} {func_name}({func_args})",
+                        visibility=vis,
+                        modifiers=tuple(filter(None, [func_mod])),
+                        content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                    ))
+
+            prop_match = prop_pattern.match(line)
+            if prop_match and not line.strip().startswith("return") and not line.strip().startswith("import"):
+                prop_mod = prop_match.group(1)
+                prop_type = prop_match.group(2) or "dynamic"
+                prop_name = prop_match.group(3)
+                if prop_name and prop_name not in ("return", "break", "continue", "throw"):
+                    vis = Visibility.PRIVATE if prop_name.startswith("_") else Visibility.PUBLIC
+                    parent_id = current_type if current_type and brace_depth > type_depth else file_path
+                    sym_id = f"{parent_id}::{prop_name}"
+                    symbols.append(Symbol(
+                        id=sym_id,
+                        name=prop_name,
+                        qualified_name=prop_name,
+                        kind=SymbolKind.VARIABLE,
+                        language=self.language,
+                        location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                        parent_id=parent_id,
+                        signature=f"{prop_type} {prop_name}",
+                        visibility=vis,
+                        modifiers=tuple(filter(None, [prop_mod])),
+                        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, mixin, and import edges for Dart.
+        Example:
+            >>> analyzer = DartLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.dart"), "class Child extends Parent with Logger implements IService {}")
+            >>> 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|mixin|enum|extension)\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([a-zA-Z0-9_.,\s<>]+))?(?:\s+with\s+([a-zA-Z0-9_.,\s<>]+))?(?:\s+implements\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)
+                implements_raw = type_match.group(4)
+                type_sym = symbol_map.get(type_name)
+                if type_sym:
+                    super_candidates = []
+                    if extends_raw:
+                        super_candidates.append(extends_raw.strip().split("<")[0].strip())
+                    if with_raw:
+                        for w in with_raw.split(","):
+                            clean_w = w.strip().split("<")[0].strip()
+                            if clean_w:
+                                super_candidates.append(clean_w)
+                    if implements_raw:
+                        for imp in implements_raw.split(","):
+                            clean_imp = imp.strip().split("<")[0].strip()
+                            if clean_imp:
+                                super_candidates.append(clean_imp)
+                    for sup in super_candidates:
+                        if sup and sup not in ("Object", "Widget", "StatelessWidget", "StatefulWidget"):
+                            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 ") or line.strip().startswith("export "):
+                imp_match = re.search(r'[\'"]([^\'"]+)[\'"]', line)
+                if imp_match:
+                    target_uri = imp_match.group(1)
+                    edges.append(Edge(
+                        source_id=file_path,
+                        target_id=target_uri,
+                        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 Dart imports (relative or package:) against workspace files.
+        Example:
+            >>> analyzer = DartLanguageAnalyzer()
+            >>> from codeui.core.resolver import ResolveContext
+            >>> ctx = ResolveContext(Path("."))
+            >>> ref = ImportRef("lib/main.dart", "package:app/service.dart", None, False)
+            >>> list(analyzer.resolve_import(ref, ctx))
+            []
+        """
+        uri = ref.module_name
+        if uri.startswith("package:"):
+            parts = uri[len("package:"):].split("/", 1)
+            if len(parts) > 1:
+                pkg_sub = f"lib/{parts[1]}"
+                cands = ctx.resolve_path(ref.from_file, pkg_sub, "dart")
+                if cands:
+                    return cands
+                return ctx.resolve_path(ref.from_file, parts[1], "dart")
+        return ctx.resolve_path(ref.from_file, uri, "dart")

codeui/lang/generic.py

@@ -1,11 +1,14 @@
 """Generic markup, config, and fallback language analyzer for codeui."""
+from __future__ import annotations
 import hashlib
 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 GenericLanguageAnalyzer(LanguageAnalyzer):
     """Fallback analyzer for configuration, markup, and generic source files.
     Example:
@@ -19,8 +22,7 @@ class GenericLanguageAnalyzer(LanguageAnalyzer):
     has_ast_support: ClassVar[bool] = False
     is_supported: ClassVar[bool] = False
     extensions: ClassVar[tuple[str, ...]] = (
-        ".java", ".kt", ".cs", ".rb", ".php", ".swift", ".vue", ".svelte",
-        ".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".m", ".mm", ".scala"
+        ".vue", ".svelte", ".m", ".mm", ".xml", ".html"
     )
 
     def parse(self, path: Path, source: str) -> ParseResult:

codeui/lang/go.py

@@ -1,12 +1,15 @@
 """Go 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 GoLanguageAnalyzer(LanguageAnalyzer):
     """Go language analyzer.
     Example:

codeui/lang/java.py

@@ -0,0 +1,320 @@
+"""Java and Kotlin 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 JavaLanguageAnalyzer(LanguageAnalyzer):
+    """Java and Kotlin language analyzer.
+    Example:
+        >>> analyzer = JavaLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("Main.java"), 'public class Main { public static void main(String[] args) {} }')
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.name == "Main" for s in syms)
+        True
+    """
+    language: ClassVar[str] = "java"
+    extensions: ClassVar[tuple[str, ...]] = (".java", ".kt")
+    has_ast_support: ClassVar[bool] = True
+    is_supported: ClassVar[bool] = True
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse Java or Kotlin source code into ParseResult.
+        Example:
+            >>> analyzer = JavaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.java"), "package com.example;")
+            >>> 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 classes, interfaces, records, enums, and methods from Java/Kotlin source.
+        Example:
+            >>> analyzer = JavaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("User.java"), "public class User { public String getName() { return name; } }")
+            >>> 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)
+
+        import_pattern = re.compile(r'import\s+(?:static\s+)?([A-Za-z0-9_.*]+)\s*;')
+        class_pattern = re.compile(r'(?:public|protected|private)?\s*(?:abstract|final|static)?\s*(?:class|interface|record|enum)\s+([A-Za-z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([A-Za-z0-9_$.]+))?(?:\s+implements\s+([A-Za-z0-9_$,\s]+))?')
+        method_pattern = re.compile(r'(?:public|protected|private|static|final|synchronized|abstract|\s)+[\w<>\[\]]+\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)')
+        kt_fun_pattern = re.compile(r'(?:public|private|protected|internal)?\s*fun\s+(?:<[^>]+>\s+)?([A-Za-z0-9_]+)\s*\(([^)]*)\)')
+
+        js_keywords = {"if", "for", "while", "switch", "catch", "return", "throw", "new", "class", "interface", "package", "import", "else", "try", "finally"}
+        class_ranges: List[tuple[str, str, int, int, str, str]] = []
+
+        for idx, line in enumerate(lines, start=1):
+            line_str = line.strip()
+            if not line_str or line_str.startswith("//") or line_str.startswith("*"):
+                continue
+
+            for match in import_pattern.finditer(line_str):
+                imp_path = match.group(1)
+                sym_id = f"import:{imp_path}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=imp_path.split(".")[-1],
+                    qualified_name=f"import:{imp_path}",
+                    kind=SymbolKind.IMPORT,
+                    language=self.language,
+                    location=Location(file_path, idx, line.find(imp_path), idx, line.find(imp_path) + len(imp_path)),
+                    parent_id=file_path,
+                    signature=f"import {imp_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 js_keywords:
+                    continue
+                ext_name = match.group(2) or ""
+                impl_names = match.group(3) or ""
+                sym_id = f"{file_path}::{cls_name}"
+                end_line = self._find_block_end(lines, idx - 1)
+                class_ranges.append((cls_name, sym_id, idx, end_line, ext_name, impl_names))
+                loc = Location(file_path, idx, line.find(cls_name), end_line, line.find(cls_name) + len(cls_name))
+                vis = Visibility.PUBLIC if "public" in line_str else (Visibility.PRIVATE if "private" in line_str else Visibility.INTERNAL)
+                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=vis,
+                    modifiers=("public",) if "public" in line_str else (),
+                    content_hash=self._extract_body_hash(lines, idx - 1),
+                ))
+
+            for match in method_pattern.finditer(line_str):
+                m_name = match.group(1)
+                params = match.group(2)
+                if m_name in js_keywords or m_name in ("if", "for", "while", "switch", "catch", "return"):
+                    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
+                else:
+                    sym_id = f"{file_path}::{m_name}"
+                    qual_name = m_name
+                    parent_sym_id = file_path
+                end_line = self._find_block_end(lines, idx - 1)
+                loc = Location(file_path, idx, line.find(m_name), end_line, line.find(m_name) + len(m_name))
+                vis = Visibility.PUBLIC if "public" in line_str else (Visibility.PRIVATE if "private" in line_str else Visibility.INTERNAL)
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=m_name,
+                    qualified_name=qual_name,
+                    kind=SymbolKind.METHOD,
+                    language=self.language,
+                    location=loc,
+                    parent_id=parent_sym_id,
+                    signature=f"{m_name}({params})",
+                    visibility=vis,
+                    modifiers=("public",) if "public" in line_str else (),
+                    content_hash=self._extract_body_hash(lines, idx - 1),
+                ))
+
+            for match in kt_fun_pattern.finditer(line_str):
+                m_name = match.group(1)
+                params = match.group(2)
+                if m_name in js_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
+                else:
+                    sym_id = f"{file_path}::{m_name}"
+                    qual_name = m_name
+                    parent_sym_id = file_path
+                end_line = self._find_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=SymbolKind.FUNCTION,
+                    language=self.language,
+                    location=loc,
+                    parent_id=parent_sym_id,
+                    signature=f"fun {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 Java / Kotlin AST.
+        Example:
+            >>> analyzer = JavaLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.java"), "import com.example.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|interface|record|enum)\s+([A-Za-z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([A-Za-z0-9_$.]+))?(?:\s+implements\s+([A-Za-z0-9_$,\s]+))?')
+        call_pattern = re.compile(r'(?<![A-Za-z0-9_$-])\b([A-Za-z_][A-Za-z0-9_]*)\s*\(')
+        java_keywords = {"if", "for", "while", "switch", "catch", "return", "throw", "new", "super", "this"}
+
+        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("//") or line_str.startswith("*"):
+                continue
+            for match in class_pattern.finditer(line_str):
+                cls_name = match.group(1)
+                ext_name = match.group(2)
+                impl_names = match.group(3)
+                cls_sym_id = f"{file_path}::{cls_name}"
+                if ext_name:
+                    base_clean = ext_name.strip().split("<")[0].strip()
+                    loc = Location(file_path, idx, line.find(base_clean), idx, line.find(base_clean) + len(base_clean))
+                    edges.append(Edge(
+                        source_id=cls_sym_id,
+                        target_id=f"module::{base_clean}",
+                        kind=EdgeKind.INHERITS,
+                        weight=1.0,
+                        confidence=0.9,
+                        location=loc,
+                    ))
+                if impl_names:
+                    for iface in impl_names.split(","):
+                        iface_clean = iface.strip().split("<")[0].strip()
+                        if iface_clean and iface_clean not in java_keywords:
+                            loc = Location(file_path, idx, line.find(iface_clean), idx, line.find(iface_clean) + len(iface_clean))
+                            edges.append(Edge(
+                                source_id=cls_sym_id,
+                                target_id=f"module::{iface_clean}",
+                                kind=EdgeKind.IMPLEMENTS,
+                                weight=1.0,
+                                confidence=0.9,
+                                location=loc,
+                            ))
+
+        method_syms = [s for s in symbols if s.kind in (SymbolKind.METHOD, SymbolKind.FUNCTION)]
+        name_to_syms: dict[str, list[Symbol]] = {}
+        for s in method_syms:
+            name_to_syms.setdefault(s.name, []).append(s)
+
+        for m in method_syms:
+            if not m.location:
+                continue
+            m_lines = lines[m.location.start_line - 1 : m.location.end_line]
+            for m_line in m_lines:
+                for match in call_pattern.finditer(m_line):
+                    callee_name = match.group(1)
+                    if callee_name in java_keywords or callee_name == m.name:
+                        continue
+                    if callee_name in name_to_syms:
+                        target = name_to_syms[callee_name][0]
+                        edges.append(Edge(
+                            source_id=m.id,
+                            target_id=target.id,
+                            kind=EdgeKind.CALLS,
+                            weight=1.0,
+                            confidence=0.85,
+                            location=m.location,
+                        ))
+
+        return edges
+
+    def resolve_import(self, ref: ImportRef, ctx: ResolveContext) -> Iterable[str]:
+        """Resolve Java import references to project files.
+        Example:
+            >>> analyzer = JavaLanguageAnalyzer()
+            >>> ctx = ResolveContext(Path("."))
+            >>> list(analyzer.resolve_import(ImportRef("App.java", "com.example.Helper", None, False), ctx))
+            []
+        """
+        clean_path = ref.module_name.replace(".", "/")
+        return ctx.resolve_path(ref.file_path, clean_path, self.language)
+
+    def _find_block_end(self, lines: List[str], start_idx: int) -> int:
+        open_braces = 0
+        found_brace = False
+        for i in range(start_idx, len(lines)):
+            line = lines[i]
+            open_braces += line.count("{") - line.count("}")
+            if "{" in line:
+                found_brace = True
+            if found_brace and open_braces <= 0:
+                return i + 1
+        return min(start_idx + 30, len(lines))
+
+    def _extract_body_hash(self, lines: List[str], start_idx: int) -> str:
+        end_idx = self._find_block_end(lines, start_idx)
+        snippet = "\n".join(lines[start_idx:end_idx])
+        return hashlib.sha256(snippet.encode("utf-8")).hexdigest()