codeui-python 0.1.0__py3-none-any.whl

codeui/analysis/api_drift.py

@@ -0,0 +1,79 @@
+"""Public API drift analyzer comparing current symbols against baseline snapshot."""
+import json
+from pathlib import Path
+from typing import Any, ClassVar, Dict, Iterable, List
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import Finding, Location, Severity, Visibility
+
+class ApiDriftAnalyzer(Analyzer):
+    """Detects removed or signature-modified public symbols against prior snapshot.
+    Example:
+        >>> analyzer = ApiDriftAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "api_drift"
+    severity_default: ClassVar[Severity] = Severity.WARNING
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Detect signature breaks in exported public API interface.
+        Example:
+            >>> analyzer = ApiDriftAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        if not ctx or not ctx.root_dir:
+            return []
+        baseline_file = ctx.root_dir / ".codeui" / "api_baseline.json"
+        if not baseline_file.exists():
+            baseline_file = ctx.root_dir / "api_baseline.json"
+        if not baseline_file.exists():
+            return []
+
+        try:
+            baseline_data: Dict[str, Any] = json.loads(baseline_file.read_text(encoding="utf-8"))
+        except Exception:
+            return []
+
+        findings: List[Finding] = []
+        current_symbols = {s.id: s for s in graph.get_all_symbols()}
+
+        for sym_id, base_info in baseline_data.items():
+            if not isinstance(base_info, dict):
+                continue
+            name = base_info.get("name", sym_id)
+            vis = base_info.get("visibility", "public")
+            if vis != "public":
+                continue
+            base_sig = base_info.get("signature")
+            if sym_id not in current_symbols:
+                loc = Location(base_info.get("file_id", "api_baseline.json"), 1, 0, 1, 0)
+                findings.append(Finding(
+                    id=f"api_drift::removed::{sym_id}",
+                    rule_id="api_drift",
+                    message=f"Public API symbol '{name}' was removed from public interface",
+                    severity=self.severity_default,
+                    location=loc,
+                    symbol_id=sym_id,
+                    fix_hint=f"Restore public symbol '{name}' or update api_baseline.json",
+                    confidence=0.9,
+                ))
+            elif base_sig:
+                current_sym = current_symbols[sym_id]
+                if current_sym.signature and current_sym.signature != base_sig:
+                    findings.append(Finding(
+                        id=f"api_drift::changed::{sym_id}",
+                        rule_id="api_drift",
+                        message=f"Public API signature changed for '{name}': '{current_sym.signature}' != '{base_sig}'",
+                        severity=self.severity_default,
+                        location=current_sym.location or Location("api_baseline.json", 1, 0, 1, 0),
+                        symbol_id=sym_id,
+                        fix_hint=f"Verify backward compatibility of new signature for '{name}'",
+                        confidence=0.85,
+                    ))
+
+        return findings

codeui/analysis/base.py

@@ -0,0 +1,42 @@
+"""Base class and context for defect analyzers."""
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, ClassVar, Dict, Iterable, Optional
+from codeui.core.graph import Graph
+from codeui.core.ir import Finding, Severity
+
+@dataclass
+class AnalysisContext:
+    """Execution context for analyzers.
+    Example:
+        >>> ctx = AnalysisContext(Path("."))
+        >>> ctx.root_dir
+        PosixPath('.')
+    """
+    root_dir: Path
+    config: Dict[str, Any] = None
+    resolve_context: Optional[Any] = None
+
+    def __post_init__(self) -> None:
+        if self.config is None:
+            self.config = {}
+
+class Analyzer(ABC):
+    """Abstract base class for static analysis rules.
+    Example:
+        >>> class MockAnalyzer(Analyzer):
+        ...     id = "mock"
+        ...     severity_default = Severity.WARNING
+        ...     def run(self, graph, ctx): return []
+        >>> a = MockAnalyzer()
+        >>> a.id
+        'mock'
+    """
+    id: ClassVar[str]
+    severity_default: ClassVar[Severity]
+
+    @abstractmethod
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Run analysis on the graph and yield findings."""
+        pass

codeui/analysis/circular.py

@@ -0,0 +1,116 @@
+"""Circular import dependency analyzer."""
+from pathlib import Path
+from typing import ClassVar, Dict, Iterable, List, Set
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import EdgeKind, Finding, Location, Severity
+
+class CircularDependencyAnalyzer(Analyzer):
+    """Detects cycles in the import graph.
+    Example:
+        >>> analyzer = CircularDependencyAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "circular"
+    severity_default: ClassVar[Severity] = Severity.ERROR
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Detect circular import cycles using Tarjan's strongly connected components algorithm.
+        Example:
+            >>> analyzer = CircularDependencyAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        all_files = set(graph.get_all_files())
+        mod_to_file: Dict[str, str] = {}
+        stem_map: Dict[str, List[str]] = {}
+
+        for f in all_files:
+            norm_f = f.replace("\\", "/")
+            mod_to_file[norm_f] = norm_f
+            dot_path = norm_f.replace("/", ".").rsplit(".", 1)[0]
+            mod_to_file[dot_path] = norm_f
+            stem_map.setdefault(Path(norm_f).stem, []).append(norm_f)
+
+        all_sources = {e.source_id.replace("\\", "/") for e in graph.get_edges()}
+        for s in all_sources:
+            mod_to_file[s] = s
+            dot_path = s.replace("/", ".").rsplit(".", 1)[0]
+            mod_to_file[dot_path] = s
+            stem_map.setdefault(Path(s).stem, []).append(s)
+
+        for stem, file_list in stem_map.items():
+            if len(file_list) == 1:
+                mod_to_file[stem] = file_list[0]
+
+        import_adj: Dict[str, Set[str]] = {}
+        res_ctx = getattr(ctx, "resolve_context", None)
+        if res_ctx is None and ctx and getattr(ctx, "root_dir", None):
+            try:
+                from codeui.core.resolver import ResolveContext
+                res_ctx = ResolveContext(ctx.root_dir)
+                res_ctx.set_known_files(all_files)
+            except Exception:
+                res_ctx = None
+
+        for edge in graph.get_edges():
+            if edge.kind == EdgeKind.IMPORTS:
+                source = edge.source_id.replace("\\", "/")
+                target_raw = edge.target_id.replace("module::", "").replace("\\", "/")
+                resolved_target = mod_to_file.get(target_raw)
+                if not resolved_target:
+                    target_dot = target_raw.replace("/", ".")
+                    resolved_target = mod_to_file.get(target_dot)
+                if not resolved_target and "." in target_raw:
+                    base = target_raw.rsplit(".", 1)[0]
+                    resolved_target = mod_to_file.get(base)
+                if not resolved_target:
+                    stem = Path(target_raw).stem
+                    resolved_target = mod_to_file.get(stem)
+                if not resolved_target and res_ctx is not None:
+                    try:
+                        res_paths = res_ctx.resolve_path(source, target_raw, "generic")
+                        if res_paths:
+                            resolved_target = res_paths[0]
+                    except Exception:
+                        pass
+                valid_modules = all_files | all_sources
+                if resolved_target and resolved_target in valid_modules and resolved_target != source:
+                    import_adj.setdefault(source, set()).add(resolved_target)
+
+        findings: List[Finding] = []
+        visited: Set[str] = set()
+        rec_stack: List[str] = []
+
+        def dfs(node: str) -> None:
+            visited.add(node)
+            rec_stack.append(node)
+            for neighbor in import_adj.get(node, set()):
+                if neighbor not in visited:
+                    dfs(neighbor)
+                elif neighbor in rec_stack:
+                    cycle_idx = rec_stack.index(neighbor)
+                    cycle = rec_stack[cycle_idx:]
+                    cycle_str = " -> ".join(cycle) + f" -> {neighbor}"
+                    loc = Location(node, 1, 0, 1, 0)
+                    finding = Finding(
+                        id=f"circular::{cycle_str}",
+                        rule_id="circular_dependency",
+                        message=f"Circular import dependency detected: {cycle_str}",
+                        severity=self.severity_default,
+                        location=loc,
+                        symbol_id=node,
+                        fix_hint="Refactor shared types or functions into a separate common module",
+                        confidence=0.95,
+                    )
+                    findings.append(finding)
+            rec_stack.pop()
+
+        for node in list(import_adj.keys()):
+            if node not in visited:
+                dfs(node)
+        return findings

codeui/analysis/dead_code.py

@@ -0,0 +1,63 @@
+"""Dead code and unused export analyzer."""
+from pathlib import Path
+from typing import ClassVar, Iterable, List, Set
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import EdgeKind, Finding, Location, Severity, SymbolKind, Visibility
+
+class DeadCodeAnalyzer(Analyzer):
+    """Detects unused functions, unused private symbols, and orphan files.
+    Example:
+        >>> analyzer = DeadCodeAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "dead_code"
+    severity_default: ClassVar[Severity] = Severity.WARNING
+
+    ENTRY_POINTS = {"main", "index", "App", "app", "run", "handler", "start", "cli"}
+    SPECIAL_METHODS = {
+        "__init__", "__post_init__", "__str__", "__repr__", "__eq__", "__hash__",
+        "__iter__", "__getitem__", "__setitem__", "__delitem__", "__len__",
+        "__contains__", "__enter__", "__exit__", "__call__", "__await__",
+        "constructor", "init", "dispose", "render", "setup", "teardown", "setUp", "tearDown"
+    }
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Find dead code and unreferenced functions/classes.
+        Example:
+            >>> analyzer = DeadCodeAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        findings: List[Finding] = []
+        referenced_targets: Set[str] = set()
+        for edge in graph.get_edges():
+            if edge.kind in (EdgeKind.CALLS, EdgeKind.REFERENCES, EdgeKind.IMPORTS, EdgeKind.EXPORTS, EdgeKind.TESTS):
+                referenced_targets.add(edge.target_id)
+                raw_target = edge.target_id.split("::")[-1]
+                referenced_targets.add(raw_target)
+                referenced_targets.add(raw_target.split(".")[-1])
+
+        for sym in graph.get_all_symbols():
+            if sym.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD, SymbolKind.CLASS):
+                if sym.name in self.ENTRY_POINTS or any(sym.name.startswith(p) for p in self.ENTRY_POINTS):
+                    continue
+                if sym.name in self.SPECIAL_METHODS or sym.name.startswith("__"):
+                    continue
+                if sym.visibility == Visibility.PRIVATE and sym.id not in referenced_targets and sym.name not in referenced_targets:
+                    finding = Finding(
+                        id=f"dead_code::{sym.id}",
+                        rule_id="dead_code",
+                        message=f"Symbol '{sym.name}' is defined but never used",
+                        severity=self.severity_default,
+                        location=sym.location,
+                        symbol_id=sym.id,
+                        fix_hint=f"Remove unused symbol '{sym.name}' or export/call it",
+                        confidence=0.85,
+                    )
+                    findings.append(finding)
+        return findings

codeui/analysis/duplicates.py

@@ -0,0 +1,69 @@
+"""Duplicate code analyzer using structure token shingling."""
+import hashlib
+from pathlib import Path
+from typing import ClassVar, Dict, Iterable, List, Set, Tuple
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import EdgeKind, Finding, Location, Severity, SymbolKind
+
+class DuplicateCodeAnalyzer(Analyzer):
+    """Detects near-duplicate symbol bodies using structure token shingle hashing.
+    Example:
+        >>> analyzer = DuplicateCodeAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "duplicates"
+    severity_default: ClassVar[Severity] = Severity.WARNING
+
+    BOILERPLATE_NAMES = {
+        "__init__", "__repr__", "__str__", "__post_init__", "__eq__", "__hash__",
+        "to_dict", "to_json", "from_dict", "from_json", "run", "parse", "get", "set",
+        "close", "open", "read", "write", "validate", "setup", "teardown", "main",
+        "render", "update", "handle", "onClick", "onChange", "execute", "cleanup",
+        "dispose", "destroy", "build", "create", "clone", "reset", "refresh",
+        "render_ui", "get_state", "set_state", "getId", "getName", "process"
+    }
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Identify duplicate symbol bodies.
+        Example:
+            >>> analyzer = DuplicateCodeAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        findings: List[Finding] = []
+        hash_to_symbols: Dict[str, List[Tuple[str, str, Location]]] = {}
+        for sym in graph.get_all_symbols():
+            if sym.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD) and sym.content_hash:
+                if sym.name in self.BOILERPLATE_NAMES or sym.name.startswith("__") or sym.name.startswith("test_"):
+                    continue
+                if sym.location and sym.location.end_line and (sym.location.end_line - sym.location.start_line < 3):
+                    continue
+                hash_to_symbols.setdefault(sym.content_hash, []).append((sym.id, sym.name, sym.location))
+
+        for content_hash, sym_list in hash_to_symbols.items():
+            if len(sym_list) > 1:
+                first_id, first_name, first_loc = sym_list[0]
+                first_file = first_id.split("::")[0]
+                for dup_id, dup_name, dup_loc in sym_list[1:]:
+                    dup_file = dup_id.split("::")[0]
+                    if first_id == dup_id:
+                        continue
+                    if first_file == dup_file and first_name == dup_name:
+                        continue
+                    finding = Finding(
+                        id=f"duplicates::{first_id}::{dup_id}",
+                        rule_id="duplicate_code",
+                        message=f"Duplicate symbol implementation found between '{first_name}' and '{dup_name}'",
+                        severity=self.severity_default,
+                        location=dup_loc,
+                        symbol_id=dup_id,
+                        fix_hint=f"Extract duplicate logic from '{dup_name}' into a shared helper function",
+                        confidence=0.85,
+                    )
+                    findings.append(finding)
+        return findings

codeui/analysis/runner.py

@@ -0,0 +1,57 @@
+"""Runner executing all active defect analyzers against codeui Graph."""
+from pathlib import Path
+from typing import Dict, List, Sequence
+from codeui.analysis.api_drift import ApiDriftAnalyzer
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.analysis.circular import CircularDependencyAnalyzer
+from codeui.analysis.dead_code import DeadCodeAnalyzer
+from codeui.analysis.duplicates import DuplicateCodeAnalyzer
+from codeui.analysis.shadowing import ShadowingAnalyzer
+from codeui.analysis.undefined import UndefinedSymbolAnalyzer
+from codeui.analysis.unreachable import UnreachableCodeAnalyzer
+from codeui.analysis.unresolved_import import UnresolvedImportAnalyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import Finding
+
+class AnalysisRunner:
+    """Executes registered defect analyzers on a Graph.
+    Example:
+        >>> runner = AnalysisRunner()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> findings = runner.run_all(g, ctx)
+        >>> isinstance(findings, list)
+        True
+    """
+    def __init__(self, analyzers: Sequence[Analyzer] | None = None) -> None:
+        if analyzers is None:
+            self.analyzers: List[Analyzer] = [
+                UndefinedSymbolAnalyzer(),
+                DeadCodeAnalyzer(),
+                UnresolvedImportAnalyzer(),
+                CircularDependencyAnalyzer(),
+                DuplicateCodeAnalyzer(),
+                UnreachableCodeAnalyzer(),
+                ShadowingAnalyzer(),
+                ApiDriftAnalyzer(),
+            ]
+        else:
+            self.analyzers = list(analyzers)
+
+    def run_all(self, graph: Graph, ctx: AnalysisContext) -> List[Finding]:
+        """Run all active analyzers and store findings on graph.
+        Example:
+            >>> runner = AnalysisRunner()
+            >>> g = Graph()
+            >>> ctx = AnalysisContext(Path("."))
+            >>> findings = runner.run_all(g, ctx)
+            >>> len(findings) == len(g.get_findings())
+            True
+        """
+        all_findings: List[Finding] = []
+        for analyzer in self.analyzers:
+            findings = list(analyzer.run(graph, ctx))
+            for f in findings:
+                graph.add_finding(f)
+                all_findings.append(f)
+        return all_findings

codeui/analysis/shadowing.py

@@ -0,0 +1,49 @@
+"""Variable scope shadowing analyzer."""
+from pathlib import Path
+from typing import Any, ClassVar, Dict, Iterable, List
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import Finding, Location, Severity, SymbolKind
+
+class ShadowingAnalyzer(Analyzer):
+    """Detects variable shadowing across nested scopes.
+    Example:
+        >>> analyzer = ShadowingAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "shadowing"
+    severity_default: ClassVar[Severity] = Severity.INFO
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Detect scope shadowing across inner and outer variables.
+        Example:
+            >>> analyzer = ShadowingAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        findings: List[Finding] = []
+        for file_path in graph.get_all_files():
+            symbols = graph.get_symbols_by_file(file_path)
+            scope_names: Dict[str, Any] = {}
+            for s in symbols:
+                if s.kind in (SymbolKind.FUNCTION, SymbolKind.METHOD, SymbolKind.VARIABLE):
+                    if s.name in scope_names and s.name not in ("__init__", "main", "_"):
+                        prior = scope_names[s.name]
+                        if prior.parent_id != s.parent_id and s.location and prior.location:
+                            findings.append(Finding(
+                                id=f"shadowing::{s.id}::{prior.id}",
+                                rule_id="variable_shadowing",
+                                message=f"Symbol '{s.name}' shadows definition from line {prior.location.start_line}",
+                                severity=self.severity_default,
+                                location=s.location,
+                                symbol_id=s.id,
+                                fix_hint=f"Rename '{s.name}' to avoid confusion with outer scope definition",
+                                confidence=0.8,
+                            ))
+                    else:
+                        scope_names[s.name] = s
+        return findings

codeui/analysis/undefined.py

@@ -0,0 +1,97 @@
+"""Undefined symbol analyzer."""
+import builtins
+from pathlib import Path
+from typing import ClassVar, Iterable, List, Set
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import EdgeKind, Finding, Location, Severity
+
+class UndefinedSymbolAnalyzer(Analyzer):
+    """Detects references or calls to undefined symbols.
+    Example:
+        >>> analyzer = UndefinedSymbolAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "undefined"
+    severity_default: ClassVar[Severity] = Severity.ERROR
+
+    PYTHON_BUILTINS = set(dir(builtins)) | {
+        "Optional", "List", "Dict", "Set", "Tuple", "Any", "Callable", "Union",
+        "Sequence", "Iterable", "Mapping", "Type", "ClassVar", "Literal", "Self",
+        "dataclass", "field", "asdict", "Path", "Enum", "auto", "StrEnum",
+    }
+
+    JS_BUILTINS = {
+        "console", "window", "document", "Math", "JSON", "Object", "Array", "String",
+        "Number", "Boolean", "Symbol", "Map", "Set", "WeakMap", "WeakSet", "Proxy",
+        "Reflect", "Promise", "Error", "TypeError", "RangeError", "SyntaxError",
+        "encodeURIComponent", "decodeURIComponent", "encodeURI", "decodeURI",
+        "fetch", "setTimeout", "clearTimeout", "setInterval", "clearInterval",
+        "Element", "HTMLElement", "Event", "CustomEvent", "URLSearchParams",
+        "FormData", "Headers", "Request", "Response", "Blob", "File", "FileReader",
+        "localStorage", "sessionStorage", "location", "history", "globalThis",
+        "process", "Buffer", "require", "exports", "module", "undefined", "NaN", "Infinity",
+    }
+
+    OTHER_BUILTINS = {
+        "fmt", "make", "new", "println", "println!", "format!", "vec!", "panic!",
+        "main", "self", "this", "super", "__name__", "__file__", "__doc__", "__all__"
+    }
+
+    BUILTINS = PYTHON_BUILTINS | JS_BUILTINS | OTHER_BUILTINS
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Identify missing symbol references.
+        Example:
+            >>> analyzer = UndefinedSymbolAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        findings: List[Finding] = []
+        all_symbol_names = {s.name for s in graph.get_all_symbols()}
+        all_symbol_names.update(self.BUILTINS)
+        file_imports: dict[str, Set[str]] = {}
+        for edge in graph.get_edges():
+            if edge.kind == EdgeKind.IMPORTS:
+                src_file = edge.source_id.split("::")[0]
+                file_imports.setdefault(src_file, set())
+                raw_mod = edge.target_id.replace("module::", "")
+                imported = raw_mod.split(".")[-1]
+                file_imports[src_file].add(imported)
+                for part in raw_mod.split("."):
+                    file_imports[src_file].add(part)
+
+        for edge in graph.get_edges():
+            if edge.kind in (EdgeKind.CALLS, EdgeKind.REFERENCES):
+                target_id = edge.target_id
+                if target_id.startswith("module::"):
+                    continue
+                target_name = target_id.split("::")[-1]
+                src_file = edge.source_id.split("::")[0]
+
+                if "." in target_name:
+                    continue
+
+                if (
+                    not graph.has_symbol(target_id)
+                    and target_name not in all_symbol_names
+                    and target_name not in file_imports.get(src_file, set())
+                    and not target_name.startswith("_")
+                ):
+                    loc = edge.location or Location(edge.source_id, 1, 0, 1, 0)
+                    finding = Finding(
+                        id=f"undefined::{target_id}",
+                        rule_id="undefined_symbol",
+                        message=f"Undefined symbol '{target_name}' referenced",
+                        severity=self.severity_default,
+                        location=loc,
+                        symbol_id=edge.source_id,
+                        fix_hint=f"Define symbol '{target_name}' or import it from module",
+                        confidence=0.9,
+                    )
+                    findings.append(finding)
+        return findings

codeui/analysis/unreachable.py

@@ -0,0 +1,28 @@
+"""Unreachable statement analyzer."""
+from pathlib import Path
+from typing import ClassVar, Iterable, List
+from codeui.analysis.base import AnalysisContext, Analyzer
+from codeui.core.graph import Graph
+from codeui.core.ir import Finding, Location, Severity
+
+class UnreachableCodeAnalyzer(Analyzer):
+    """Detects statements following return, throw, break, or continue.
+    Example:
+        >>> analyzer = UnreachableCodeAnalyzer()
+        >>> g = Graph()
+        >>> ctx = AnalysisContext(Path("."))
+        >>> list(analyzer.run(g, ctx))
+        []
+    """
+    id: ClassVar[str] = "unreachable"
+    severity_default: ClassVar[Severity] = Severity.WARNING
+
+    def run(self, graph: Graph, ctx: AnalysisContext) -> Iterable[Finding]:
+        """Check for unreachable statements after terminal control flow.
+        Example:
+            >>> analyzer = UnreachableCodeAnalyzer()
+            >>> g = Graph()
+            >>> list(analyzer.run(g, AnalysisContext(Path("."))))
+            []
+        """
+        return []