lerev 2.6.0__py3-none-any.whl

adapters/__init__.py

@@ -0,0 +1,14 @@
+"""Harness adapter registry.
+
+Provides the central registry for discovering and instantiating
+harness adapters that connect the learning engine to various
+AI coding assistants.
+"""
+
+from adapters.base import HarnessAdapter, AdapterConfig, AdapterCapability
+
+__all__ = [
+    "HarnessAdapter",
+    "AdapterConfig",
+    "AdapterCapability",
+]

adapters/base.py

@@ -0,0 +1,104 @@
+"""Abstract harness adapter interface.
+
+The core contract that all harness adapters must implement to communicate
+with the learning engine. Each adapter bridges a specific AI coding
+assistant (OpenCode, Claude Code, Codex, etc.) to the engine's unified
+learning pipeline.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any
+
+
+class AdapterCapability(Enum):
+    """Capabilities an adapter may advertise."""
+
+    CODE_GENERATION = auto()
+    CODE_EXPLANATION = auto()
+    FILE_EDITING = auto()
+    TERMINAL_ACCESS = auto()
+    WEB_SEARCH = auto()
+    CONTEXT_INJECTION = auto()
+
+
+@dataclass
+class AdapterConfig:
+    """Configuration for a harness adapter."""
+
+    name: str
+    enabled: bool = True
+    options: dict[str, Any] = field(default_factory=dict)
+    capabilities: list[AdapterCapability] = field(default_factory=list)
+
+
+@dataclass
+class AdapterResponse:
+    """Standardised response from an adapter interaction."""
+
+    content: str
+    success: bool = True
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class HarnessAdapter(ABC):
+    """Abstract base class for harness adapters.
+
+    Each concrete adapter wraps a specific AI coding assistant and
+    translates between the engine's learning events and the assistant's
+    native interface.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique identifier for this adapter (e.g. 'opencode', 'claude_code')."""
+        ...
+
+    @property
+    @abstractmethod
+    def capabilities(self) -> list[AdapterCapability]:
+        """Capabilities supported by this adapter."""
+        ...
+
+    @abstractmethod
+    async def configure(self, config: AdapterConfig) -> None:
+        """Apply configuration to the adapter.
+
+        Args:
+            config: The adapter configuration.
+        """
+        ...
+
+    @abstractmethod
+    async def send_prompt(self, prompt: str, context: dict[str, Any] | None = None) -> AdapterResponse:
+        """Send a prompt to the underlying harness and return the response.
+
+        Args:
+            prompt: The prompt text.
+            context: Optional context (file state, prior conversation, etc.).
+
+        Returns:
+            An AdapterResponse with the harness output.
+        """
+        ...
+
+    @abstractmethod
+    async def inject_context(self, context: dict[str, Any]) -> None:
+        """Inject learning context into the harness session.
+
+        Args:
+            context: Context data (e.g. relevant docs, code snippets).
+        """
+        ...
+
+    @abstractmethod
+    async def health_check(self) -> bool:
+        """Return True if the underlying harness is reachable and ready."""
+        ...
+
+    @abstractmethod
+    async def shutdown(self) -> None:
+        """Cleanly shut down the adapter and release resources."""
+        ...

adapters/claude_code/__init__.py

@@ -0,0 +1,5 @@
+"""Claude Code adapter package."""
+
+from adapters.claude_code.adapter import ClaudeCodeAdapter
+
+__all__ = ["ClaudeCodeAdapter"]

adapters/claude_code/adapter.py

@@ -0,0 +1,44 @@
+"""Claude Code harness adapter stub."""
+
+from adapters.base import HarnessAdapter, AdapterConfig, AdapterCapability, AdapterResponse
+from typing import Any
+
+
+class ClaudeCodeAdapter(HarnessAdapter):
+    """Adapter for the Claude Code harness.
+
+    Bridges the learning engine to Claude Code's interface.
+    """
+
+    @property
+    def name(self) -> str:
+        return "claude_code"
+
+    @property
+    def capabilities(self) -> list[AdapterCapability]:
+        return [
+            AdapterCapability.CODE_GENERATION,
+            AdapterCapability.CODE_EXPLANATION,
+            AdapterCapability.FILE_EDITING,
+            AdapterCapability.WEB_SEARCH,
+        ]
+
+    async def configure(self, config: AdapterConfig) -> None:
+        """Apply configuration to the adapter."""
+        raise NotImplementedError
+
+    async def send_prompt(self, prompt: str, context: dict[str, Any] | None = None) -> AdapterResponse:
+        """Send a prompt to Claude Code and return the response."""
+        raise NotImplementedError
+
+    async def inject_context(self, context: dict[str, Any]) -> None:
+        """Inject learning context into the Claude Code session."""
+        raise NotImplementedError
+
+    async def health_check(self) -> bool:
+        """Return True if Claude Code is reachable."""
+        raise NotImplementedError
+
+    async def shutdown(self) -> None:
+        """Cleanly shut down the adapter."""
+        raise NotImplementedError

adapters/codex/__init__.py

@@ -0,0 +1,5 @@
+"""Codex adapter package."""
+
+from adapters.codex.adapter import CodexAdapter
+
+__all__ = ["CodexAdapter"]

adapters/codex/adapter.py

@@ -0,0 +1,42 @@
+"""Codex harness adapter stub."""
+
+from adapters.base import HarnessAdapter, AdapterConfig, AdapterCapability, AdapterResponse
+from typing import Any
+
+
+class CodexAdapter(HarnessAdapter):
+    """Adapter for the Codex harness.
+
+    Bridges the learning engine to OpenAI Codex's interface.
+    """
+
+    @property
+    def name(self) -> str:
+        return "codex"
+
+    @property
+    def capabilities(self) -> list[AdapterCapability]:
+        return [
+            AdapterCapability.CODE_GENERATION,
+            AdapterCapability.CODE_EXPLANATION,
+        ]
+
+    async def configure(self, config: AdapterConfig) -> None:
+        """Apply configuration to the adapter."""
+        raise NotImplementedError
+
+    async def send_prompt(self, prompt: str, context: dict[str, Any] | None = None) -> AdapterResponse:
+        """Send a prompt to Codex and return the response."""
+        raise NotImplementedError
+
+    async def inject_context(self, context: dict[str, Any]) -> None:
+        """Inject learning context into the Codex session."""
+        raise NotImplementedError
+
+    async def health_check(self) -> bool:
+        """Return True if Codex is reachable."""
+        raise NotImplementedError
+
+    async def shutdown(self) -> None:
+        """Cleanly shut down the adapter."""
+        raise NotImplementedError

adapters/generic/__init__.py

@@ -0,0 +1,5 @@
+"""Generic adapter package."""
+
+from adapters.generic.adapter import GenericAdapter
+
+__all__ = ["GenericAdapter"]

adapters/generic/adapter.py

@@ -0,0 +1,43 @@
+"""Generic harness adapter stub."""
+
+from adapters.base import HarnessAdapter, AdapterConfig, AdapterCapability, AdapterResponse
+from typing import Any
+
+
+class GenericAdapter(HarnessAdapter):
+    """Adapter for generic or custom harnesses.
+
+    A fallback adapter that can be configured to talk to any harness
+    exposing a simple prompt/response interface.
+    """
+
+    @property
+    def name(self) -> str:
+        return "generic"
+
+    @property
+    def capabilities(self) -> list[AdapterCapability]:
+        return [
+            AdapterCapability.CODE_GENERATION,
+            AdapterCapability.CODE_EXPLANATION,
+        ]
+
+    async def configure(self, config: AdapterConfig) -> None:
+        """Apply configuration to the adapter."""
+        raise NotImplementedError
+
+    async def send_prompt(self, prompt: str, context: dict[str, Any] | None = None) -> AdapterResponse:
+        """Send a prompt to the generic harness and return the response."""
+        raise NotImplementedError
+
+    async def inject_context(self, context: dict[str, Any]) -> None:
+        """Inject learning context into the generic harness session."""
+        raise NotImplementedError
+
+    async def health_check(self) -> bool:
+        """Return True if the generic harness is reachable."""
+        raise NotImplementedError
+
+    async def shutdown(self) -> None:
+        """Cleanly shut down the adapter."""
+        raise NotImplementedError

adapters/opencode/__init__.py

@@ -0,0 +1,5 @@
+"""OpenCode adapter package."""
+
+from adapters.opencode.adapter import OpenCodeAdapter
+
+__all__ = ["OpenCodeAdapter"]

adapters/opencode/adapter.py

@@ -0,0 +1,44 @@
+"""OpenCode harness adapter stub."""
+
+from adapters.base import HarnessAdapter, AdapterConfig, AdapterCapability, AdapterResponse
+from typing import Any
+
+
+class OpenCodeAdapter(HarnessAdapter):
+    """Adapter for the OpenCode harness.
+
+    Bridges the learning engine to OpenCode's CLI and API surface.
+    """
+
+    @property
+    def name(self) -> str:
+        return "opencode"
+
+    @property
+    def capabilities(self) -> list[AdapterCapability]:
+        return [
+            AdapterCapability.CODE_GENERATION,
+            AdapterCapability.CODE_EXPLANATION,
+            AdapterCapability.FILE_EDITING,
+            AdapterCapability.TERMINAL_ACCESS,
+        ]
+
+    async def configure(self, config: AdapterConfig) -> None:
+        """Apply configuration to the adapter."""
+        raise NotImplementedError
+
+    async def send_prompt(self, prompt: str, context: dict[str, Any] | None = None) -> AdapterResponse:
+        """Send a prompt to OpenCode and return the response."""
+        raise NotImplementedError
+
+    async def inject_context(self, context: dict[str, Any]) -> None:
+        """Inject learning context into the OpenCode session."""
+        raise NotImplementedError
+
+    async def health_check(self) -> bool:
+        """Return True if OpenCode is reachable."""
+        raise NotImplementedError
+
+    async def shutdown(self) -> None:
+        """Cleanly shut down the adapter."""
+        raise NotImplementedError

core/__init__.py

@@ -0,0 +1,17 @@
+"""Core interfaces for the AI Learning Engine.
+
+This package defines the abstract base classes and type definitions
+for the learning engine system. It is implementation-agnostic and
+does not depend on any specific harness (OpenCode, Claude, etc.).
+"""
+
+from __future__ import annotations
+
+__version__: str = "0.1.0"
+__all__: list[str] = [
+    "Learner",
+    "MemoryStore",
+    "Evaluator",
+    "AdaptationEngine",
+    "KnowledgeBase",
+]

core/adaptation/__init__.py

@@ -0,0 +1,7 @@
+"""Adaptation interfaces."""
+
+from __future__ import annotations
+
+from core.adaptation.base import AdaptationEngine
+
+__all__: list[str] = ["AdaptationEngine"]

core/adaptation/base.py

@@ -0,0 +1,85 @@
+"""Abstract base class for the AdaptationEngine component.
+
+An AdaptationEngine modifies learner behaviour based on evaluation
+feedback. It bridges evaluation results and parameter updates,
+enabling curriculum adjustments, hyperparameter tuning, or
+meta-learning strategies.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+class AdaptationStrategy(Enum):
+    """High-level adaptation strategy."""
+
+    GRADIENT = auto()
+    LerevLUTIONARY = auto()
+    META_LEARNING = auto()
+    HEURISTIC = auto()
+
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True, slots=True)
+class AdaptationSignal:
+    """Feedback signal fed into an AdaptationEngine."""
+
+    metric_name: str
+    current_value: float
+    target_value: float | None = None
+    context: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class AdaptationAction:
+    """An action that the AdaptationEngine recommends."""
+
+    parameter: str
+    old_value: Any
+    new_value: Any
+    reason: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Abstract interface
+# ---------------------------------------------------------------------------
+
+class AdaptationEngine(ABC):
+    """Interface that every adaptation strategy must implement."""
+
+    @abstractmethod
+    def propose(self, signals: list[AdaptationSignal]) -> list[AdaptationAction]:
+        """Analyse signals and propose parameter changes.
+
+        Args:
+            signals: Current feedback signals.
+
+        Returns:
+            A list of recommended actions.
+        """
+
+    @abstractmethod
+    def apply(self, actions: list[AdaptationAction]) -> dict[str, Any]:
+        """Apply a set of actions and return the outcome.
+
+        Args:
+            actions: Actions to execute.
+
+        Returns:
+            A dict describing what was actually applied.
+        """
+
+    @property
+    @abstractmethod
+    def strategy(self) -> AdaptationStrategy:
+        """Return the underlying adaptation strategy."""

core/evaluator/__init__.py

@@ -0,0 +1,7 @@
+"""Evaluation interfaces."""
+
+from __future__ import annotations
+
+from core.evaluator.base import Evaluator
+
+__all__: list[str] = ["Evaluator"]

core/evaluator/base.py

@@ -0,0 +1,91 @@
+"""Abstract base class for the Evaluator component.
+
+An Evaluator assesses the quality of learner outputs, policies, or
+behaviours against one or more metrics. Concrete implementations may
+wrap statistical tests, LLM-as-judge scoring, or domain-specific
+benchmarks.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+class EvalScale(Enum):
+    """Scale used by an evaluation metric."""
+
+    BINARY = auto()
+    CONTINUOUS = auto()
+    ORDINAL = auto()
+
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True, slots=True)
+class EvalMetric:
+    """Definition of a single evaluation metric."""
+
+    name: str
+    scale: EvalScale = EvalScale.CONTINUOUS
+    range_min: float = 0.0
+    range_max: float = 1.0
+    higher_is_better: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class EvalResult:
+    """Outcome of evaluating a single sample against a set of metrics."""
+
+    scores: dict[str, float]
+    details: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class EvalReport:
+    """Aggregated results across many samples."""
+
+    results: list[EvalResult]
+    summary: dict[str, float] = field(default_factory=dict)
+
+
+# ---------------------------------------------------------------------------
+# Abstract interface
+# ---------------------------------------------------------------------------
+
+class Evaluator(ABC):
+    """Interface that every evaluator must implement."""
+
+    @abstractmethod
+    def evaluate(self, sample: dict[str, Any]) -> EvalResult:
+        """Evaluate a single sample.
+
+        Args:
+            sample: The data to evaluate.
+
+        Returns:
+            An ``EvalResult`` with per-metric scores.
+        """
+
+    @abstractmethod
+    def aggregate(self, results: list[EvalResult]) -> EvalReport:
+        """Aggregate multiple evaluation results.
+
+        Args:
+            results: Individual results to aggregate.
+
+        Returns:
+            A summary ``EvalReport``.
+        """
+
+    @property
+    @abstractmethod
+    def metrics(self) -> list[EvalMetric]:
+        """Return the list of metrics this evaluator uses."""

core/interfaces.py

@@ -0,0 +1,21 @@
+"""Centralized exports for all core interfaces.
+
+Re-exports every abstract base class and data model so consumers can
+do ``from core.interfaces import Learner, Evaluator, ...``.
+"""
+
+from __future__ import annotations
+
+from core.adaptation.base import AdaptationEngine
+from core.evaluator.base import Evaluator
+from core.knowledge.base import KnowledgeBase
+from core.learner.base import Learner
+from core.memory.base import MemoryStore
+
+__all__: list[str] = [
+    "Learner",
+    "MemoryStore",
+    "Evaluator",
+    "AdaptationEngine",
+    "KnowledgeBase",
+]

core/knowledge/__init__.py

@@ -0,0 +1,7 @@
+"""Knowledge acquisition interfaces."""
+
+from __future__ import annotations
+
+from core.knowledge.base import KnowledgeBase
+
+__all__: list[str] = ["KnowledgeBase"]

core/knowledge/base.py

@@ -0,0 +1,108 @@
+"""Abstract base class for the KnowledgeBase component.
+
+A KnowledgeBase maintains structured knowledge (rules, facts,
+ontologies) that can be queried and updated. Concrete implementations
+may use graph databases, semantic stores, or simple dictionaries.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum, auto
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+class KnowledgeType(Enum):
+    """Type of knowledge entry."""
+
+    FACT = auto()
+    RULE = auto()
+    HYPOTHESIS = auto()
+    METADATA = auto()
+
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True, slots=True)
+class KnowledgeEntry:
+    """A single piece of knowledge."""
+
+    subject: str
+    predicate: str
+    obj: Any
+    knowledge_type: KnowledgeType = KnowledgeType.FACT
+    confidence: float = 1.0
+    source: str = ""
+    created_at: datetime = field(default_factory=datetime.now)
+
+
+@dataclass(frozen=True, slots=True)
+class KnowledgeQuery:
+    """Parameters for querying the knowledge base."""
+
+    subject: str | None = None
+    predicate: str | None = None
+    knowledge_type: KnowledgeType | None = None
+    min_confidence: float = 0.0
+    limit: int = 100
+
+
+# ---------------------------------------------------------------------------
+# Abstract interface
+# ---------------------------------------------------------------------------
+
+class KnowledgeBase(ABC):
+    """Interface that every knowledge store must implement."""
+
+    @abstractmethod
+    def add(self, entry: KnowledgeEntry) -> None:
+        """Insert a new knowledge entry.
+
+        Args:
+            entry: The knowledge to add.
+        """
+
+    @abstractmethod
+    def query(self, query: KnowledgeQuery) -> list[KnowledgeEntry]:
+        """Retrieve entries matching *query*.
+
+        Args:
+            query: Search parameters.
+
+        Returns:
+            A list of matching entries.
+        """
+
+    @abstractmethod
+    def update(self, entry: KnowledgeEntry) -> bool:
+        """Update an existing entry (matched by subject + predicate).
+
+        Args:
+            entry: Updated knowledge.
+
+        Returns:
+            ``True`` if the entry existed and was updated.
+        """
+
+    @abstractmethod
+    def remove(self, subject: str, predicate: str) -> bool:
+        """Remove entries matching the given subject/predicate pair.
+
+        Returns:
+            ``True`` if at least one entry was removed.
+        """
+
+    @abstractmethod
+    def count(self) -> int:
+        """Return the total number of knowledge entries."""
+
+    @abstractmethod
+    def clear(self) -> None:
+        """Remove all entries from the knowledge base."""

core/learner/__init__.py

@@ -0,0 +1,7 @@
+"""Learning engine interfaces."""
+
+from __future__ import annotations
+
+from core.learner.base import Learner
+
+__all__: list[str] = ["Learner"]