honestcode 0.5.0__py3-none-any.whl

honestcode/sandbox/__init__.py

@@ -0,0 +1,334 @@
+"""
+Sandboxed code execution for HonestCode.
+
+Executes code in a fresh Python subprocess with resource limits:
+  - POSIX: RLIMIT_AS (memory), RLIMIT_CPU (cpu time), RLIMIT_NOFILE (open files)
+  - Windows: Job Object with process-memory and job CPU-time limits, plus
+    kill-on-close, applied via ctypes (best effort; silently skipped when the
+    Job Object API is unavailable)
+  - Both: wall-clock timeout, isolated temp directory, restricted PYTHONPATH
+
+Threat model — read this before trusting it: the sandbox is a guardrail
+against *accidents* (infinite loops, fork bombs, runaway memory, typo'd
+paths), not a security boundary. The child runs as the current user with full
+file-system and network access, and environment scrubbing is name-based
+guesswork. Do not execute code from untrusted authors inside it; use a real
+isolation layer (container, VM) for that.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["ExecutionResult", "SandboxExecutor"]
+
+# Environment variable names containing these markers are scrubbed before
+# the sandboxed subprocess starts. This is best-effort name guessing: it
+# catches the common credential names but cannot know every scheme a secret
+# might hide under (see the threat model above).
+_SENSITIVE_ENV_MARKERS = (
+    "KEY",
+    "TOKEN",
+    "SECRET",
+    "PASSWORD",
+    "PASSWD",
+    "CREDENTIAL",
+    "AUTH",
+    "SIGNATURE",
+    "DATABASE",
+    "DSN",
+)
+
+
+@dataclass
+class ExecutionResult:
+    success: bool
+    stdout: str = ""
+    stderr: str = ""
+    output: str = ""
+    error: str = ""
+    error_type: str = ""
+    runtime_seconds: float = 0.0
+    details: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "success": self.success,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "output": self.output or self.stdout,
+            "error": self.error or self.stderr,
+            "error_type": self.error_type,
+            "runtime_seconds": self.runtime_seconds,
+            **self.details,
+        }
+
+
+class SandboxExecutor:
+    """Execute Python code snippets in a restricted subprocess."""
+
+    def __init__(self, timeout: int | None = None, memory_mb: int | None = None):
+        # Environment overrides (HONESTCODE_TIMEOUT / HONESTCODE_MEMORY_MB)
+        # apply when the caller does not pass explicit values.
+        env_timeout = os.environ.get("HONESTCODE_TIMEOUT", "")
+        self.timeout = (
+            timeout if timeout is not None else int(env_timeout) if env_timeout.isdigit() else 10
+        )
+        env_memory = os.environ.get("HONESTCODE_MEMORY_MB", "")
+        self.memory_mb = (
+            memory_mb if memory_mb is not None else int(env_memory) if env_memory.isdigit() else 256
+        )
+
+    def execute(
+        self,
+        code: str,
+        prelude: str = "",
+        known_names: set[str] | None = None,
+    ) -> ExecutionResult:
+        """Run *code* in a fresh Python interpreter and return the result."""
+        known_names = known_names or set()
+        start = time.perf_counter()
+
+        with tempfile.TemporaryDirectory(prefix="honestcode_sandbox_") as tmpdir:
+            script_path = Path(tmpdir) / "script.py"
+            full_code = f"{prelude}\n{code}\n"
+            script_path.write_text(full_code, encoding="utf-8")
+
+            env = {
+                k: v
+                for k, v in os.environ.items()
+                if not any(marker in k.upper() for marker in _SENSITIVE_ENV_MARKERS)
+            }
+            env["PYTHONPATH"] = ""
+            env["PYTHONDONTWRITEBYTECODE"] = "1"
+
+            preexec = self._get_preexec_fn()
+            creationflags = self._get_creationflags()
+
+            try:
+                proc = subprocess.Popen(
+                    [sys.executable, "-u", str(script_path)],
+                    cwd=tmpdir,
+                    env=env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    preexec_fn=preexec,
+                    creationflags=creationflags,
+                )
+            except Exception as e:  # noqa: BLE001
+                return ExecutionResult(
+                    success=False,
+                    error=f"Sandbox failed: {e}",
+                    runtime_seconds=round(time.perf_counter() - start, 3),
+                )
+
+            # Windows: bind the child to a Job Object *after* spawn (the
+            # POSIX path applies limits pre-exec instead).
+            job_handle = self._apply_windows_job(proc)
+            try:
+                try:
+                    stdout, stderr = proc.communicate(timeout=self.timeout)
+                except subprocess.TimeoutExpired:
+                    proc.kill()
+                    stdout, stderr = proc.communicate()
+                    return ExecutionResult(
+                        success=False,
+                        error=f"Execution timed out after {self.timeout}s",
+                        stderr=(stderr or "")[:50_000],
+                        runtime_seconds=round(time.perf_counter() - start, 3),
+                        details={"timeout": True},
+                    )
+            finally:
+                self._release_windows_job(job_handle)
+
+            runtime = time.perf_counter() - start
+            stdout = stdout or ""
+            stderr = stderr or ""
+            success = proc.returncode == 0
+            err_text = stderr[:50_000] if not success else ""
+            error_type = ""
+            if not success and err_text:
+                m = re.search(r"^(\w+Error|\w+Exception)", err_text, re.MULTILINE)
+                if m:
+                    error_type = m.group(1)
+            return ExecutionResult(
+                success=success,
+                stdout=stdout[:50_000],
+                stderr=stderr[:50_000],
+                output=stdout[:50_000],
+                error=err_text,
+                error_type=error_type,
+                runtime_seconds=round(runtime, 3),
+                details={"returncode": proc.returncode, "known_names": sorted(known_names)},
+            )
+
+    def _get_preexec_fn(self):
+        """Return a POSIX preexec_fn that sets resource limits, if available.
+
+        Each limit is applied best-effort: some platforms (e.g. macOS CI
+        runners) reject certain ``setrlimit`` calls, and a single failure
+        inside ``preexec_fn`` kills the child before it can run at all.
+        """
+        if sys.platform == "win32":
+            return None
+        try:
+            import resource
+        except Exception:  # noqa: BLE001
+            return None
+
+        def limit_resources():
+            def _setrlimit(name, soft, hard):
+                try:
+                    resource.setrlimit(getattr(resource, name), (soft, hard))
+                except (ValueError, OSError):
+                    logger.warning("Could not set %s in sandbox: %s", name, sys.exc_info()[1])
+
+            # Memory limit
+            max_bytes = self.memory_mb * 1024 * 1024
+            _setrlimit("RLIMIT_AS", max_bytes, max_bytes)
+            # CPU time limit (soft = timeout, hard = timeout + 2s buffer)
+            _setrlimit("RLIMIT_CPU", self.timeout, self.timeout + 2)
+            # Limit open files to prevent fd exhaustion
+            _setrlimit("RLIMIT_NOFILE", 64, 64)
+
+        return limit_resources
+
+    def _get_creationflags(self) -> int:
+        """Return Windows-specific creation flags for process isolation."""
+        if sys.platform != "win32":
+            return 0
+        # CREATE_NO_WINDOW: don't open a console window
+        # BELOW_NORMAL_PRIORITY_CLASS: reduce scheduling priority
+        return 0x08000000 | 0x00008000
+
+    def _apply_windows_job(self, proc: subprocess.Popen) -> int | None:
+        """Assign *proc* to a Job Object with memory/CPU limits (Windows only).
+
+        Best effort by design: returns the job handle (to be released by
+        :meth:`_release_windows_job`), or ``None`` when anything about the
+        platform or API call refuses to cooperate — the wall-clock timeout
+        still applies in that case. ``KILL_ON_JOB_CLOSE`` also ties the
+        child's life to this process, so no orphan survives a crash.
+        """
+        if sys.platform != "win32":
+            return None
+        try:
+            import ctypes
+            from ctypes import wintypes
+
+            kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+            kernel32.CreateJobObjectW.restype = wintypes.HANDLE
+            kernel32.CreateJobObjectW.argtypes = [ctypes.c_void_p, wintypes.LPCWSTR]
+            kernel32.SetInformationJobObject.restype = wintypes.BOOL
+            kernel32.SetInformationJobObject.argtypes = [
+                wintypes.HANDLE,
+                ctypes.c_int,
+                ctypes.c_void_p,
+                wintypes.DWORD,
+            ]
+            kernel32.AssignProcessToJobObject.restype = wintypes.BOOL
+            kernel32.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+
+            class IO_COUNTERS(ctypes.Structure):
+                _fields_ = [
+                    (name, ctypes.c_uint64)
+                    for name in (
+                        "ReadOperationCount",
+                        "WriteOperationCount",
+                        "OtherOperationCount",
+                        "ReadTransferCount",
+                        "WriteTransferCount",
+                        "OtherTransferCount",
+                    )
+                ]
+
+            class JOBOBJECT_BASIC_LIMIT_INFORMATION(ctypes.Structure):
+                _fields_ = [
+                    ("PerProcessUserTimeLimit", ctypes.c_int64),
+                    ("PerJobUserTimeLimit", ctypes.c_int64),
+                    ("LimitFlags", wintypes.DWORD),
+                    ("MinimumWorkingSetSize", ctypes.c_size_t),
+                    ("MaximumWorkingSetSize", ctypes.c_size_t),
+                    ("ActiveProcessLimit", wintypes.DWORD),
+                    ("Affinity", ctypes.c_size_t),
+                    ("PriorityClass", wintypes.DWORD),
+                    ("SchedulingClass", wintypes.DWORD),
+                ]
+
+            class JOBOBJECT_EXTENDED_LIMIT_INFORMATION(ctypes.Structure):
+                _fields_ = [
+                    ("BasicLimitInformation", JOBOBJECT_BASIC_LIMIT_INFORMATION),
+                    ("IoInfo", IO_COUNTERS),
+                    ("ProcessMemoryLimit", ctypes.c_size_t),
+                    ("JobMemoryLimit", ctypes.c_size_t),
+                    ("PeakProcessMemoryUsed", ctypes.c_size_t),
+                    ("PeakJobMemoryUsed", ctypes.c_size_t),
+                ]
+
+            JobObjectExtendedLimitInformation = 9
+            JOB_OBJECT_LIMIT_PROCESS_MEMORY = 0x0100
+            # 0x0200 is JOB_OBJECT_LIMIT_JOB_MEMORY, not JOB_TIME. With the
+            # wrong flag the call set a job-memory limit of zero and failed
+            # with ERROR_INVALID_PARAMETER (87), so *none* of the limits —
+            # memory, CPU, kill-on-close — were applied on Windows.
+            JOB_OBJECT_LIMIT_JOB_TIME = 0x0004
+            JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x2000
+
+            job = kernel32.CreateJobObjectW(None, None)
+            if not job:
+                return None
+            info = JOBOBJECT_EXTENDED_LIMIT_INFORMATION()
+            info.BasicLimitInformation.LimitFlags = (
+                JOB_OBJECT_LIMIT_PROCESS_MEMORY
+                | JOB_OBJECT_LIMIT_JOB_TIME
+                | JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+            )
+            info.ProcessMemoryLimit = self.memory_mb * 1024 * 1024
+            # Job user CPU time is expressed in 100ns units.
+            info.BasicLimitInformation.PerJobUserTimeLimit = int(self.timeout) * 10_000_000
+            if not kernel32.SetInformationJobObject(
+                job, JobObjectExtendedLimitInformation, ctypes.byref(info), ctypes.sizeof(info)
+            ):
+                kernel32.CloseHandle(job)
+                return None
+            if not kernel32.AssignProcessToJobObject(job, int(proc._handle)):
+                kernel32.CloseHandle(job)
+                return None
+            return job
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Windows Job Object unavailable: %s", e)
+            return None
+
+    def _release_windows_job(self, job_handle: int | None) -> None:
+        """Close the Job Object handle once the child has been reaped.
+
+        Closing is what triggers ``KILL_ON_JOB_CLOSE``; by the time this runs
+        the child has exited or been killed, so the job object is empty.
+        """
+        if not job_handle:
+            return
+        try:
+            import ctypes
+            from ctypes import wintypes
+
+            kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+            kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+            kernel32.CloseHandle.restype = wintypes.BOOL
+            kernel32.CloseHandle(job_handle)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Could not close job handle: %s", e)
+
+    def validate_snippet(self, code: str, known_names: set[str]) -> ExecutionResult:
+        """Quickly run a snippet to see if it raises a NameError for unknown symbols."""
+        return self.execute(code=code, known_names=known_names)

honestcode/structure/__init__.py

@@ -0,0 +1,6 @@
+"""Structural code analysis helpers."""
+
+from honestcode.structure.extractor import StructureExtractor
+from honestcode.structure.relations import ParseResult, StructEdge
+
+__all__ = ["ParseResult", "StructEdge", "StructureExtractor"]

honestcode/structure/extractor.py

@@ -0,0 +1,353 @@
+"""
+Parse Python source files into ``ParseResult`` objects.
+
+Provides AST-based extraction of functions, classes, variables, imports,
+imports and intra-file reference edges with minimal false positives.
+
+The implementation uses the standard-library ``ast`` module directly; no
+native parser dependency is required. A ``parser`` constructor argument is
+accepted for callers who want to plug in a tree-sitter-backed parser that
+follows the same interface, but it is optional.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from honestcode.structure.relations import ParseResult, StructEdge
+from honestcode.structure.utils import annotation_name, call_name, read_python_source
+
+__all__ = ["StructureExtractor"]
+
+
+class StructureExtractor:
+    """Extract functions, classes, variables, imports and local edges from a Python file."""
+
+    def __init__(self, parser=None):
+        # ``parser`` is accepted for backwards compatibility and for callers
+        # who want to plug in an alternate parser. The default implementation
+        # uses the standard-library ``ast`` module and does not require any
+        # native dependency.
+        self.parser = parser
+
+    def parse_file(self, file_path: str | Path) -> ParseResult:
+        """Parse *file_path* and return a ``ParseResult``.
+
+        Source is decoded through :func:`read_python_source`, so a legal
+        non-UTF-8 file (a PEP 263 coding cookie) is read correctly and an
+        undecodable one is skipped rather than aborting the whole project index.
+        """
+        source = read_python_source(file_path)
+        if source is None:
+            return ParseResult(
+                edges=[],
+                func_defs={},
+                class_defs={},
+                var_defs={},
+                imports=set(),
+            )
+        return self.parse_source(source)
+
+    def parse_source(self, source: str) -> ParseResult:
+        """Parse raw source code and return a ``ParseResult``."""
+        try:
+            tree = ast.parse(source)
+        except SyntaxError:
+            # Fallback: return empty result so callers can continue.
+            return ParseResult(
+                edges=[],
+                func_defs={},
+                class_defs={},
+                var_defs={},
+                imports=set(),
+            )
+
+        func_defs: dict[str, tuple[int, int]] = {}
+        class_defs: dict[str, tuple[int, int]] = {}
+        var_defs: dict[str, tuple[int, int]] = {}
+        imports: set[str] = set()
+        imported_symbols: dict[str, str] = {}
+        class_bases: dict[str, list[str]] = {}
+        edges: list[StructEdge] = []
+
+        self._walk(
+            tree,
+            source,
+            scope="",
+            func_defs=func_defs,
+            class_defs=class_defs,
+            var_defs=var_defs,
+            imports=imports,
+            imported_symbols=imported_symbols,
+            edges=edges,
+            class_bases=class_bases,
+        )
+
+        return ParseResult(
+            edges=edges,
+            func_defs=func_defs,
+            class_defs=class_defs,
+            var_defs=var_defs,
+            imports=imports,
+            imported_symbols=imported_symbols,
+            exported_symbols={n for n in func_defs if not n.startswith("_")}
+            | {n for n in class_defs if not n.startswith("_")},
+            class_bases=class_bases,
+        )
+
+    def _walk(
+        self,
+        node: ast.AST,
+        source: str,
+        scope: str,
+        func_defs: dict[str, tuple[int, int]],
+        class_defs: dict[str, tuple[int, int]],
+        var_defs: dict[str, tuple[int, int]],
+        imports: set[str],
+        imported_symbols: dict[str, str],
+        edges: list[StructEdge],
+        class_bases: dict[str, list[str]],
+        in_function: bool = False,
+    ) -> None:
+        """Recursively walk the AST collecting definitions and edges.
+
+        ``in_function`` gates variable recording: assignments inside a function
+        body are locals, not project symbols, so they are skipped (module-level
+        and class-body assignments are still recorded).
+        """
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                name = self._scoped_name(scope, child.name)
+                func_defs[name] = (child.lineno - 1, child.end_lineno - 1)
+                self._collect_local_edges(child, name, func_defs, class_defs, var_defs, edges)
+                self._walk(
+                    child,
+                    source,
+                    scope=name,
+                    func_defs=func_defs,
+                    class_defs=class_defs,
+                    var_defs=var_defs,
+                    imports=imports,
+                    imported_symbols=imported_symbols,
+                    edges=edges,
+                    class_bases=class_bases,
+                    in_function=True,
+                )
+            elif isinstance(child, ast.ClassDef):
+                name = self._scoped_name(scope, child.name)
+                class_defs[name] = (child.lineno - 1, child.end_lineno - 1)
+                self._collect_local_edges(child, name, func_defs, class_defs, var_defs, edges)
+                bases = [b for b in (annotation_name(x) for x in child.bases) if b]
+                if bases:
+                    class_bases[name] = bases
+                self._walk(
+                    child,
+                    source,
+                    scope=name,
+                    func_defs=func_defs,
+                    class_defs=class_defs,
+                    var_defs=var_defs,
+                    imports=imports,
+                    imported_symbols=imported_symbols,
+                    edges=edges,
+                    class_bases=class_bases,
+                    # Class bodies hold class attributes, not function locals —
+                    # even when the class itself is nested in a function.
+                    in_function=False,
+                )
+            elif isinstance(child, ast.Import):
+                for alias in child.names:
+                    imports.add(alias.name.split(".")[0])
+                    asname = alias.asname or alias.name.split(".")[-1]
+                    imported_symbols[asname] = alias.name
+            elif isinstance(child, ast.ImportFrom):
+                module = child.module or ""
+                if child.level:
+                    imports.add(module.split(".")[0] if module else ".")
+                else:
+                    imports.add(module.split(".")[0])
+                for alias in child.names:
+                    if alias.name == "*":
+                        # Star imports are keyed by their source module so
+                        # several in one file do not overwrite each other;
+                        # the verifier expands them against the symbol index.
+                        imported_symbols[f"*{module}"] = module
+                        continue
+                    asname = alias.asname or alias.name
+                    imported_symbols[asname] = f"{module}.{alias.name}" if module else alias.name
+            elif isinstance(child, ast.Assign) and not in_function:
+                for target in child.targets:
+                    self._record_var_def(target, scope, var_defs)
+            elif isinstance(child, ast.AnnAssign) and not in_function:
+                if child.target is not None:
+                    self._record_var_def(child.target, scope, var_defs)
+            else:
+                self._walk(
+                    child,
+                    source,
+                    scope,
+                    func_defs=func_defs,
+                    class_defs=class_defs,
+                    var_defs=var_defs,
+                    imports=imports,
+                    imported_symbols=imported_symbols,
+                    edges=edges,
+                    class_bases=class_bases,
+                    in_function=in_function,
+                )
+
+    def _record_var_def(
+        self,
+        target: ast.expr,
+        scope: str,
+        var_defs: dict[str, tuple[int, int]],
+    ) -> None:
+        if isinstance(target, ast.Name):
+            name = self._scoped_name(scope, target.id)
+            var_defs[name] = (target.lineno - 1, target.lineno - 1)
+        elif isinstance(target, (ast.Tuple, ast.List)):
+            for elt in target.elts:
+                self._record_var_def(elt, scope, var_defs)
+
+    @staticmethod
+    def _scoped_name(scope: str, name: str) -> str:
+        return f"{scope}.{name}" if scope else name
+
+    @staticmethod
+    def _iter_own_scope(node: ast.AST):
+        """Yield every node under *node* without entering nested scopes.
+
+        Nested ``FunctionDef`` / ``ClassDef`` nodes are yielded but not
+        descended into — each of them gets its own ``_collect_local_edges``
+        pass when ``_walk`` reaches it. Walking full subtrees here made
+        extraction quadratic: a 3000-line file took ~0.7s because every
+        enclosing scope re-walked all of its descendants (313k AST visits
+        for one parse).
+        """
+        stack = list(ast.iter_child_nodes(node))
+        while stack:
+            cur = stack.pop()
+            yield cur
+            if not isinstance(cur, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                stack.extend(ast.iter_child_nodes(cur))
+
+    def _collect_local_edges(
+        self,
+        node: ast.AST,
+        context: str,
+        func_defs: dict[str, tuple[int, int]],
+        class_defs: dict[str, tuple[int, int]],
+        var_defs: dict[str, tuple[int, int]],
+        edges: list[StructEdge],
+    ) -> None:
+        """Create edges from references inside *node* to locally defined symbols."""
+        local_names = set(func_defs.keys()) | set(class_defs.keys()) | set(var_defs.keys())
+
+        for child in self._iter_own_scope(node):
+            if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Load):
+                if child.id in local_names:
+                    edges.append(
+                        StructEdge(
+                            src_start=child.lineno - 1,
+                            src_end=child.lineno - 1,
+                            tgt_start=func_defs.get(child.id, (0, 0))[0],
+                            tgt_end=func_defs.get(child.id, (0, 0))[1],
+                            relation_type="same_scope",
+                            name=child.id,
+                        )
+                    )
+            elif isinstance(child, ast.Attribute) and isinstance(child.ctx, ast.Load):
+                root_name = self._attribute_root(child)
+                if root_name and root_name in local_names:
+                    edges.append(
+                        StructEdge(
+                            src_start=child.lineno - 1,
+                            src_end=child.lineno - 1,
+                            tgt_start=func_defs.get(root_name, (0, 0))[0],
+                            tgt_end=func_defs.get(root_name, (0, 0))[1],
+                            relation_type="same_scope",
+                            name=root_name,
+                        )
+                    )
+
+    @staticmethod
+    def _attribute_root(node: ast.Attribute) -> str | None:
+        """Return the leftmost Name of an attribute chain, if any."""
+        current: ast.expr = node.value
+        while isinstance(current, ast.Attribute):
+            current = current.value
+        return current.id if isinstance(current, ast.Name) else None
+
+    def scan_file(self, file_path: str | Path) -> list[dict]:
+        """Return a list of obvious issues in a single file.
+
+        Kept for backwards compatibility; prefer the AST-based scan in
+        ``honestcode.mcp.tools`` for richer diagnostics.
+        """
+        p = Path(file_path)
+        res = self.parse_file(p)
+        source = p.read_text(encoding="utf-8")
+
+        defined = set(res.func_defs.keys()) | set(res.class_defs.keys()) | set(res.var_defs.keys())
+        defined |= res.imports
+        defined |= {
+            "print",
+            "len",
+            "range",
+            "enumerate",
+            "zip",
+            "map",
+            "filter",
+            "sorted",
+            "sum",
+            "min",
+            "max",
+            "abs",
+            "round",
+            "int",
+            "str",
+            "float",
+            "bool",
+            "list",
+            "dict",
+            "set",
+            "tuple",
+            "type",
+            "isinstance",
+            "hasattr",
+            "getattr",
+            "open",
+            "input",
+            "repr",
+            "vars",
+            "locals",
+            "globals",
+            "dir",
+            "super",
+            "Exception",
+            "ValueError",
+            "TypeError",
+            "KeyError",
+            "IndexError",
+            "AttributeError",
+        }
+
+        issues: list[dict] = []
+        try:
+            tree = ast.parse(source)
+        except SyntaxError:
+            return issues
+
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Call):
+                continue
+            name = call_name(node.func)
+            if not name:
+                continue
+            base = name.split(".")[0]
+            if base in defined or name in defined:
+                continue
+            issues.append({"type": "undefined_call", "name": name, "line": node.lineno})
+
+        return issues