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

codeui/lang/kotlin.py

@@ -0,0 +1,303 @@
+"""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 KotlinLanguageAnalyzer(LanguageAnalyzer):
+    """Kotlin language adapter extracting classes, interfaces, objects, funs, and properties.
+    Example:
+        >>> analyzer = KotlinLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("Main.kt"), "data class User(val id: Long, val name: String)")
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.kind == SymbolKind.CLASS for s in syms)
+        True
+    """
+    language: ClassVar[str] = "kotlin"
+    extensions: ClassVar[tuple[str, ...]] = (".kt", ".kts")
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse Kotlin source into AST-emulating representation.
+        Example:
+            >>> analyzer = KotlinLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.kt"), "fun 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 Kotlin packages, classes, interfaces, objects, functions, and properties.
+        Example:
+            >>> analyzer = KotlinLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("Greeter.kt"), "class Greeter { fun greet(): String = \\"hi\\" }")
+            >>> 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_.*]+)')
+        class_pattern = re.compile(r'^\s*(?:(public|private|protected|internal)\s+)?(?:(data|sealed|open|abstract|enum|annotation|inner)\s+)?(class|interface|object)\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?(?:\s*\([^)]*\))?(?:\s*:\s*([a-zA-Z0-9_.,\s<>()]+))?')
+        companion_pattern = re.compile(r'^\s*companion\s+object(?:\s+([a-zA-Z0-9_]+))?')
+        fun_pattern = re.compile(r'^\s*(?:(public|private|protected|internal)\s+)?(?:(override|open|abstract|suspend|inline|operator|infix)\s+)*fun\s+(?:<[^>]+>\s+)?([a-zA-Z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([a-zA-Z0-9_?<>,\s]+))?')
+        property_pattern = re.compile(r'^\s*(?:(public|private|protected|internal)\s+)?(?:(override|open|abstract|const)\s+)*(val|var)\s+([a-zA-Z0-9_]+)(?:\s*:\s*([a-zA-Z0-9_?<>,\s]+))?')
+
+        current_package = ""
+        current_class: str | None = None
+        brace_depth = 0
+        class_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)
+                pkg_sym = 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],
+                )
+                symbols.append(pkg_sym)
+                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
+
+            comp_match = companion_pattern.match(line)
+            if comp_match:
+                comp_name = comp_match.group(1) or "Companion"
+                parent_id = current_class or file_path
+                sym_id = f"{file_path}::{comp_name}" if not current_class else f"{current_class}::{comp_name}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=comp_name,
+                    qualified_name=f"{current_package}.{comp_name}" if current_package else comp_name,
+                    kind=SymbolKind.CLASS,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=parent_id,
+                    signature=f"companion object {comp_name}",
+                    visibility=Visibility.PUBLIC,
+                    modifiers=("companion",),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            class_match = class_pattern.match(line)
+            if class_match:
+                vis_str = class_match.group(1) or "public"
+                mod_str = class_match.group(2)
+                type_kind = class_match.group(3)
+                class_name = class_match.group(4)
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str in ("protected", "internal") else Visibility.PUBLIC)
+                kind = SymbolKind.INTERFACE if type_kind == "interface" 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}::{class_name}"
+                current_class = sym_id
+                class_depth = brace_depth
+
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=class_name,
+                    qualified_name=f"{qual_prefix}{class_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} {class_name}",
+                    visibility=vis,
+                    modifiers=modifiers,
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            fun_match = fun_pattern.match(line)
+            if fun_match:
+                vis_str = fun_match.group(1) or "public"
+                fun_mod = fun_match.group(2)
+                fun_name = fun_match.group(3)
+                fun_args = fun_match.group(4)
+                fun_ret = fun_match.group(5) or "Unit"
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str in ("protected", "internal") else Visibility.PUBLIC)
+                parent_id = current_class if current_class and brace_depth > class_depth else file_path
+                sym_id = f"{parent_id}::{fun_name}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=fun_name,
+                    qualified_name=f"{current_package}.{fun_name}" if current_package else fun_name,
+                    kind=SymbolKind.FUNCTION,
+                    language=self.language,
+                    location=Location(file_path, line_idx, 0, line_idx, len(line)),
+                    parent_id=parent_id,
+                    signature=f"fun {fun_name}({fun_args}): {fun_ret}",
+                    visibility=vis,
+                    modifiers=tuple(filter(None, [fun_mod])),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            prop_match = property_pattern.match(line)
+            if prop_match:
+                vis_str = prop_match.group(1) or "public"
+                prop_mod = prop_match.group(2)
+                val_or_var = prop_match.group(3)
+                prop_name = prop_match.group(4)
+                prop_type = prop_match.group(5) or "Any"
+                vis = Visibility.PRIVATE if vis_str == "private" else (Visibility.PROTECTED if vis_str in ("protected", "internal") else Visibility.PUBLIC)
+                parent_id = current_class if current_class and brace_depth > class_depth else file_path
+                sym_id = f"{parent_id}::{prop_name}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=prop_name,
+                    qualified_name=f"{current_package}.{prop_name}" if current_package else 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"{val_or_var} {prop_name}: {prop_type}",
+                    visibility=vis,
+                    modifiers=tuple(filter(None, [prop_mod, val_or_var])),
+                    content_hash=hashlib.sha256(line.encode("utf-8")).hexdigest()[:16],
+                ))
+
+            brace_depth += line.count("{") - line.count("}")
+            if current_class and brace_depth <= class_depth:
+                current_class = 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, imports, and calls edges for Kotlin.
+        Example:
+            >>> analyzer = KotlinLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.kt"), "class Child : Parent()")
+            >>> 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}
+        class_pattern = re.compile(r'^\s*(?:[a-zA-Z0-9_\s<>]+)?(?:class|interface|object)\s+([a-zA-Z0-9_]+)(?:<[^>]+>)?(?:\s*\([^)]*\))?\s*:\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):
+            class_match = class_pattern.match(line)
+            if class_match:
+                cls_name = class_match.group(1)
+                super_types_raw = class_match.group(2)
+                cls_sym = symbol_map.get(cls_name)
+                if cls_sym:
+                    for super_raw in super_types_raw.split(","):
+                        clean_super = super_raw.strip().split("(")[0].split("<")[0].strip()
+                        if clean_super and clean_super not in ("Any", "Serializable"):
+                            target_id = symbol_map[clean_super].id if clean_super in symbol_map else clean_super
+                            edges.append(Edge(
+                                source_id=cls_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]
+                    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 Kotlin package or class imports against workspace files.
+        Example:
+            >>> analyzer = KotlinLanguageAnalyzer()
+            >>> from codeui.core.resolver import ResolveContext
+            >>> ctx = ResolveContext(Path("."))
+            >>> ref = ImportRef("app/Main.kt", "com.example.User", None, False)
+            >>> list(analyzer.resolve_import(ref, ctx))
+            []
+        """
+        mod_name = ref.module_name.rstrip(".*")
+        candidates = ctx.resolve_path(ref.from_file, mod_name, "kotlin")
+        if not candidates and "." in mod_name:
+            leaf = mod_name.split(".")[-1]
+            candidates = ctx.resolve_path(ref.from_file, leaf, "kotlin")
+        return candidates

codeui/lang/php.py

@@ -0,0 +1,275 @@
+"""PHP 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 PHPLanguageAnalyzer(LanguageAnalyzer):
+    """PHP language analyzer.
+    Example:
+        >>> analyzer = PHPLanguageAnalyzer()
+        >>> res = analyzer.parse(Path("App.php"), '<?php namespace App; class Controller { public function index() {} }')
+        >>> syms = list(analyzer.extract_symbols(res))
+        >>> any(s.name == "Controller" for s in syms)
+        True
+    """
+    language: ClassVar[str] = "php"
+    extensions: ClassVar[tuple[str, ...]] = (".php",)
+    has_ast_support: ClassVar[bool] = True
+    is_supported: ClassVar[bool] = True
+
+    def parse(self, path: Path, source: str) -> ParseResult:
+        """Parse PHP source code into ParseResult.
+        Example:
+            >>> analyzer = PHPLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("User.php"), "<?php namespace App\Models;")
+            >>> 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 namespaces, classes, interfaces, traits, enums, functions, and methods from PHP source.
+        Example:
+            >>> analyzer = PHPLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("Post.php"), "<?php class Post { public function save() {} }")
+            >>> 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)
+
+        use_pattern = re.compile(r'use\s+([A-Za-z0-9_\\]+)(?:\s+as\s+([A-Za-z0-9_]+))?\s*;')
+        class_pattern = re.compile(r'(?:abstract|final|readonly)?\s*(?:class|interface|trait|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|abstract|\s)+function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)')
+        func_pattern = re.compile(r'function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)')
+
+        php_keywords = {"if", "for", "while", "switch", "catch", "return", "throw", "new", "class", "interface", "namespace", "use", "else", "try", "finally", "echo", "print"}
+        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("#") or line_str.startswith("*"):
+                continue
+
+            for match in use_pattern.finditer(line_str):
+                use_path = match.group(1)
+                alias = match.group(2) or use_path.split("\\")[-1]
+                sym_id = f"import:{use_path}"
+                symbols.append(Symbol(
+                    id=sym_id,
+                    name=alias,
+                    qualified_name=f"import:{use_path}",
+                    kind=SymbolKind.IMPORT,
+                    language=self.language,
+                    location=Location(file_path, idx, line.find(use_path), idx, line.find(use_path) + len(use_path)),
+                    parent_id=file_path,
+                    signature=f"use {use_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 php_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 or "abstract" in line_str or "final" 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=(),
+                    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 php_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_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.PRIVATE if "private" in line_str else (Visibility.PROTECTED if "protected" in line_str else Visibility.PUBLIC)
+                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"function {m_name}({params})",
+                    visibility=vis,
+                    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 PHP AST.
+        Example:
+            >>> analyzer = PHPLanguageAnalyzer()
+            >>> res = analyzer.parse(Path("App.php"), "<?php use App\\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|trait|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*\(')
+        php_keywords = {"if", "for", "while", "switch", "catch", "return", "throw", "new", "echo", "print", "isset", "empty", "unset"}
+
+        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:", "").replace("\\", "/")
+                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("#") 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.split("\\")[-1]
+                    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("\\")[-1]
+                        if iface_clean and iface_clean not in php_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 php_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 PHP use references to project files.
+        Example:
+            >>> analyzer = PHPLanguageAnalyzer()
+            >>> ctx = ResolveContext(Path("."))
+            >>> list(analyzer.resolve_import(ImportRef("App.php", "App\\Helper", None, False), ctx))
+            []
+        """
+        clean_path = ref.module_name.replace("\\", "/")
+        return ctx.resolve_path(ref.file_path, clean_path, self.language)

codeui/lang/python.py

@@ -1,13 +1,16 @@
 """Python language adapter using standard library ast."""
+from __future__ import annotations
 import ast
 import hashlib
 import re
 from pathlib import Path
-from typing import Any, ClassVar, Dict, Iterable, List, Optional, Sequence, Tuple
+from typing import Any, ClassVar, Dict, Iterable, List, Optional, Sequence, Tuple, 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 PythonLanguageAnalyzer(LanguageAnalyzer):
     """Python language analyzer using standard library ast.
     Example:
@@ -192,6 +195,17 @@ class PythonLanguageAnalyzer(LanguageAnalyzer):
                         location=Location(parse.file_path, node.lineno, node.col_offset, node.lineno, node.col_offset),
                     ))
         class_names = {s.name for s in symbols if s.kind == SymbolKind.CLASS}
+        extracted_sym_ids = {s.id for s in symbols}
+
+        def _extract_names(target_node: ast.AST) -> set[str]:
+            names = set()
+            if isinstance(target_node, ast.Name):
+                names.add(target_node.id)
+            elif isinstance(target_node, (ast.Tuple, ast.List)):
+                for elt in target_node.elts:
+                    names.update(_extract_names(elt))
+            return names
+
         def walk_calls(node: ast.AST, current_scope: str, class_scope: str, locals_in_scope: set[str]) -> None:
             for child in ast.iter_child_nodes(node):
                 if isinstance(child, ast.ClassDef):
@@ -219,21 +233,49 @@ class PythonLanguageAnalyzer(LanguageAnalyzer):
                         new_locals.add(child.args.vararg.arg)
                     if getattr(child.args, "kwarg", None):
                         new_locals.add(child.args.kwarg.arg)
+                    
                     for subnode in ast.walk(child):
                         if isinstance(subnode, ast.Assign):
                             for target in subnode.targets:
-                                if isinstance(target, ast.Name):
-                                    new_locals.add(target.id)
+                                new_locals.update(_extract_names(target))
                         elif isinstance(subnode, ast.AnnAssign):
-                            if isinstance(subnode.target, ast.Name):
-                                new_locals.add(subnode.target.id)
+                            new_locals.update(_extract_names(subnode.target))
+                        elif isinstance(subnode, (ast.For, ast.AsyncFor)):
+                            new_locals.update(_extract_names(subnode.target))
+                        elif isinstance(subnode, (ast.With, ast.AsyncWith)):
+                            for item in subnode.items:
+                                if item.optional_vars:
+                                    new_locals.update(_extract_names(item.optional_vars))
+                        elif isinstance(subnode, ast.ExceptHandler):
+                            if subnode.name:
+                                new_locals.add(subnode.name)
+                        elif isinstance(subnode, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
+                            for gen in subnode.generators:
+                                new_locals.update(_extract_names(gen.target))
+                                
                     walk_calls(child, func_sym_id, class_scope, new_locals)
                 elif isinstance(child, ast.Call):
                     caller_id = current_scope if current_scope else parse.file_path
                     if isinstance(child.func, ast.Name):
                         callee_name = child.func.id
                         if callee_name not in locals_in_scope:
-                            target_id = import_map.get(callee_name, f"{parse.file_path}::{callee_name}")
+                            target_id = None
+                            if current_scope:
+                                scope_parts = current_scope.split("::")[-1].split(".")
+                                for i in range(len(scope_parts), 0, -1):
+                                    candidate_prefix = ".".join(scope_parts[:i])
+                                    candidate_id = f"{parse.file_path}::{candidate_prefix}.{callee_name}"
+                                    if candidate_id in extracted_sym_ids:
+                                        target_id = candidate_id
+                                        break
+                            
+                            if not target_id:
+                                candidate_id = f"{parse.file_path}::{callee_name}"
+                                if candidate_id in extracted_sym_ids:
+                                    target_id = candidate_id
+                                else:
+                                    target_id = import_map.get(callee_name, f"{parse.file_path}::{callee_name}")
+
                             weight = float(self._count_symbol_usages(parse.source, callee_name))
                             edges.append(Edge(
                                 source_id=caller_id,