codevanta 0.1.0__py3-none-any.whl

codevanta/ir/__init__.py

@@ -0,0 +1,6 @@
+"""Intermediate representation layer (adapter-ready, phase 1)."""
+
+from .base import IRAdapter
+from .instruction import IRInstruction
+
+__all__ = ["IRAdapter", "IRInstruction"]

codevanta/ir/adapters/__init__.py

@@ -0,0 +1,31 @@
+"""Registry for IR adapters. Concrete adapters arrive in phase 4."""
+
+from __future__ import annotations
+
+from ..base import IRAdapter
+
+_ADAPTERS: dict[str, type[IRAdapter]] = {}
+
+
+def register_adapter(adapter_cls: type[IRAdapter]) -> type[IRAdapter]:
+    """Register an adapter class under its ``name`` attribute."""
+    if not adapter_cls.name or adapter_cls.name == "base":
+        raise ValueError("adapter must define a unique non-'base' name")
+    _ADAPTERS[adapter_cls.name] = adapter_cls
+    return adapter_cls
+
+
+def available_adapters() -> list[str]:
+    """Return the names of all registered adapters."""
+    return sorted(_ADAPTERS)
+
+
+def get_adapter(name: str) -> IRAdapter:
+    """Instantiate a registered adapter by name."""
+    try:
+        return _ADAPTERS[name]()
+    except KeyError as exc:
+        raise KeyError(f"Unknown IR adapter: {name!r}") from exc
+
+
+__all__ = ["register_adapter", "available_adapters", "get_adapter"]

codevanta/ir/base.py

@@ -0,0 +1,31 @@
+"""IR adapter contract for future lifting backends (VEX, P-Code, ...)."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from .instruction import IRInstruction
+
+
+class IRAdapter(ABC):
+    """Base class for instruction lifting backends.
+
+    Adapters convert structural instructions into an intermediate
+    representation. Phase 1 ships no concrete adapter; the contract keeps the
+    core engine independent from any specific IR.
+    """
+
+    name: str = "base"
+
+    @abstractmethod
+    def lift(self, instruction: IRInstruction) -> Sequence[dict[str, Any]]:
+        """Lift one instruction into IR operations."""
+
+    def lift_many(self, instructions: Iterable[IRInstruction]) -> list[dict[str, Any]]:
+        """Lift several instructions, preserving their order."""
+        lifted: list[dict[str, Any]] = []
+        for instruction in instructions:
+            lifted.extend(self.lift(instruction))
+        return lifted

codevanta/ir/instruction.py

@@ -0,0 +1,42 @@
+"""Normalized instruction model shared by all IR adapters."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class IRInstruction:
+    """A single decoded instruction in a backend-neutral form.
+
+    Phase 1 fills the structural fields only (address, size, mnemonic,
+    operands, raw bytes). ``ir_ops`` stays empty until an adapter (VEX,
+    P-Code, custom) lifts the instruction in a later phase.
+    """
+
+    address: int
+    size: int
+    mnemonic: str
+    operands: str
+    raw_bytes: bytes
+    section: str | None = None
+    ir_ops: tuple[dict[str, Any], ...] = field(default_factory=tuple)
+
+    @property
+    def text(self) -> str:
+        """Return ``"mnemonic operands"`` (or just the mnemonic)."""
+        return f"{self.mnemonic} {self.operands}".strip()
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "address": f"0x{self.address:x}",
+            "size": self.size,
+            "bytes": self.raw_bytes.hex(),
+            "mnemonic": self.mnemonic,
+            "operands": self.operands,
+            "text": self.text,
+        }
+        if self.section:
+            data["section"] = self.section
+        return data

codevanta/mcp_server/__init__.py

@@ -0,0 +1,5 @@
+"""CODEVANTA MCP server package."""
+
+from .server import SERVER_NAME, SERVER_VERSION, build_server, run
+
+__all__ = ["SERVER_NAME", "SERVER_VERSION", "build_server", "run"]