codecortex-context-engine 0.1.0a1__py3-none-any.whl

codecortex/runtime.py

@@ -0,0 +1,69 @@
+"""Runtime assembly for CLI and integration entry points."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from codecortex.backends.factory import build_backend_stack
+from codecortex.backends.manager import BackendManager
+from codecortex.config import CortexConfig
+from codecortex.engines import EngineRegistry
+from codecortex.gateway import CodeCortexGateway
+from codecortex.memory import JsonMemoryStore
+from codecortex.orchestrator import Orchestrator
+from codecortex.router import AdaptiveRouter
+from codecortex.telemetry import TelemetryCollector
+from codecortex.tracing import TaskTraceRecorder
+
+
+@dataclass(slots=True)
+class CortexRuntime:
+    config: CortexConfig
+    memory: JsonMemoryStore
+    registry: EngineRegistry
+    router: AdaptiveRouter
+    telemetry: TelemetryCollector
+    tracer: TaskTraceRecorder
+    backend_manager: BackendManager
+    active_backends: tuple[str, ...]
+    orchestrator: Orchestrator
+    gateway: CodeCortexGateway
+
+
+def build_runtime(project_root: Path | None = None) -> CortexRuntime:
+    config = CortexConfig(project_root=(project_root or Path.cwd()).resolve())
+    config.ensure_directories()
+    memory = JsonMemoryStore(config.memory_dir)
+    stack = build_backend_stack(config, memory)
+    router = AdaptiveRouter(default_budget=config.default_context_budget)
+    telemetry = TelemetryCollector(
+        enabled=config.telemetry_enabled,
+        log_path=config.state_dir / "runtime" / "events.jsonl",
+    )
+    tracer = TaskTraceRecorder(config.state_dir / "runtime" / "traces.jsonl")
+    orchestrator = Orchestrator(
+        registry=stack.registry,
+        router=router,
+        context_processor=stack.context_processor,
+        telemetry=telemetry,
+        tracer=tracer,
+    )
+    gateway = CodeCortexGateway(
+        router=router,
+        orchestrator=orchestrator,
+        registry=stack.registry,
+        memory=memory,
+    )
+    return CortexRuntime(
+        config=config,
+        memory=memory,
+        registry=stack.registry,
+        router=router,
+        telemetry=telemetry,
+        tracer=tracer,
+        backend_manager=stack.manager,
+        active_backends=stack.active,
+        orchestrator=orchestrator,
+        gateway=gateway,
+    )

codecortex/setup.py

@@ -0,0 +1,100 @@
+"""One-command project setup and integration discovery."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from codecortex.indexing.incremental import IncrementalIndex, IndexStats
+from codecortex.indexing.indexer import ProjectIndexer
+from codecortex.memory.knowledge import ProjectKnowledge, ProjectKnowledgeExtractor
+
+
+@dataclass(frozen=True, slots=True)
+class SetupResult:
+    index: IndexStats
+    graph_nodes: int
+    graph_edges: int
+    symbols: int
+    languages: tuple[str, ...]
+    knowledge: ProjectKnowledge
+    detected_agents: tuple[str, ...]
+    integration_file: Path
+
+
+class ProjectSetup:
+    AGENTS = {
+        "Claude Code": ("claude",),
+        "Codex": ("codex",),
+        "OpenCode": ("opencode",),
+        "Gemini CLI": ("gemini",),
+    }
+
+    def __init__(self, root: Path) -> None:
+        self.root = root.resolve()
+        self.state = self.root / ".codecortex"
+
+    def detect_agents(self) -> tuple[str, ...]:
+        detected = [
+            name
+            for name, commands in self.AGENTS.items()
+            if any(shutil.which(command) for command in commands)
+        ]
+        if (self.root / ".cursor").exists():
+            detected.append("Cursor")
+        return tuple(sorted(set(detected)))
+
+    def _write_config(self) -> None:
+        config = {
+            "version": 1,
+            "context_budget": 32000,
+            "hard_context_limit": 128000,
+            "telemetry": True,
+        }
+        path = self.state / "config.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+    def _write_integration(self, detected: tuple[str, ...]) -> Path:
+        path = self.state / "integrations" / "mcp.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "mcpServers": {
+                "codecortex": {
+                    "command": "cortex",
+                    "args": ["mcp", "--path", str(self.root)],
+                }
+            },
+            "detectedAgents": list(detected),
+        }
+        path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        return path
+
+    def run(self) -> SetupResult:
+        self._write_config()
+        index = IncrementalIndex(self.root).refresh()
+        graph = ProjectIndexer(self.root).build()
+        graph_path = self.state / "index" / "graph.json"
+        graph.save(graph_path)
+        knowledge = ProjectKnowledgeExtractor(self.root).extract()
+        ProjectKnowledgeExtractor(self.root).save(knowledge)
+        detected = self.detect_agents()
+        integration = self._write_integration(detected)
+        counts = graph.counts()
+        symbol_count = sum(
+            count
+            for kind, count in counts.items()
+            if kind not in {"file", "module", "reference"}
+        )
+        return SetupResult(
+            index=index,
+            graph_nodes=len(graph.nodes),
+            graph_edges=len(graph.edges),
+            symbols=symbol_count,
+            languages=tuple(name for name, _ in knowledge.languages),
+            knowledge=knowledge,
+            detected_agents=detected,
+            integration_file=integration,
+        )

codecortex/symbols/__init__.py

@@ -0,0 +1,5 @@
+"""Language-aware symbol extraction."""
+
+from codecortex.symbols.providers import SymbolProviderRegistry, SymbolRecord
+
+__all__ = ["SymbolProviderRegistry", "SymbolRecord"]

codecortex/symbols/providers.py

@@ -0,0 +1,192 @@
+"""Lightweight multi-language symbol providers."""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class SymbolRecord:
+    name: str
+    kind: str
+    path: Path
+    line: int
+    language: str
+    container: str | None = None
+
+
+class SymbolProvider(Protocol):
+    language: str
+    suffixes: tuple[str, ...]
+
+    def extract(self, path: Path, source: str) -> list[SymbolRecord]: ...
+
+
+class PythonProvider:
+    language = "python"
+    suffixes = (".py",)
+
+    def extract(self, path: Path, source: str) -> list[SymbolRecord]:
+        try:
+            tree = ast.parse(source, filename=str(path))
+        except SyntaxError:
+            return []
+        result: list[SymbolRecord] = []
+        parents: dict[ast.AST, str] = {}
+        for parent in ast.walk(tree):
+            for child in ast.iter_child_nodes(parent):
+                if isinstance(parent, ast.ClassDef):
+                    parents[child] = parent.name
+                elif parent in parents:
+                    parents[child] = parents[parent]
+        for node in ast.walk(tree):
+            container = parents.get(node)
+            if isinstance(node, ast.ClassDef):
+                result.append(SymbolRecord(node.name, "class", path, node.lineno, self.language))
+            elif isinstance(node, ast.AsyncFunctionDef):
+                kind = "method" if container else "async_function"
+                result.append(
+                    SymbolRecord(node.name, kind, path, node.lineno, self.language, container)
+                )
+            elif isinstance(node, ast.FunctionDef):
+                kind = "method" if container else "function"
+                result.append(
+                    SymbolRecord(node.name, kind, path, node.lineno, self.language, container)
+                )
+            elif isinstance(node, (ast.Import, ast.ImportFrom)):
+                names: list[str] = []
+                if isinstance(node, ast.Import):
+                    names = [alias.name for alias in node.names]
+                elif node.module:
+                    names = [node.module]
+                for name in names:
+                    result.append(SymbolRecord(name, "import", path, node.lineno, self.language))
+        return result
+
+
+@dataclass(frozen=True, slots=True)
+class Pattern:
+    kind: str
+    regex: re.Pattern[str]
+    group: int = 1
+
+
+class RegexProvider:
+    def __init__(self, language: str, suffixes: tuple[str, ...], patterns: list[Pattern]) -> None:
+        self.language = language
+        self.suffixes = suffixes
+        self.patterns = patterns
+
+    def extract(self, path: Path, source: str) -> list[SymbolRecord]:
+        result: list[SymbolRecord] = []
+        seen: set[tuple[str, str, int]] = set()
+        for pattern in self.patterns:
+            for match in pattern.regex.finditer(source):
+                name = match.group(pattern.group).strip()
+                line = source.count("\n", 0, match.start()) + 1
+                key = (name, pattern.kind, line)
+                if not name or key in seen:
+                    continue
+                seen.add(key)
+                result.append(SymbolRecord(name, pattern.kind, path, line, self.language))
+        return result
+
+
+def _p(kind: str, expression: str, flags: int = re.MULTILINE) -> Pattern:
+    return Pattern(kind, re.compile(expression, flags))
+
+
+_JS_PATTERNS = [
+    _p("class", r"^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)"),
+    _p("interface", r"^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)"),
+    _p("type", r"^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*="),
+    _p("enum", r"^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)"),
+    _p("function", r"^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)"),
+    _p("function", r"^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^\n]*\)\s*=>"),
+    _p("import", r"^\s*import\s+(?:[^\n]+?\s+from\s+)?[\"']([^\"']+)[\"']"),
+    _p("export", r"^\s*export\s+\{\s*([^}\n]+)\s*\}"),
+]
+
+_GO_PATTERNS = [
+    _p("function", r"^\s*func\s+([A-Za-z_]\w*)\s*\("),
+    _p("method", r"^\s*func\s*\([^)]*\)\s*([A-Za-z_]\w*)\s*\("),
+    _p("type", r"^\s*type\s+([A-Za-z_]\w*)\s+(?:struct|interface)\b"),
+    _p("import", r"^\s*import\s+[\"']([^\"']+)[\"']"),
+]
+
+_RUST_PATTERNS = [
+    _p("function", r"^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)"),
+    _p("struct", r"^\s*(?:pub\s+)?struct\s+([A-Za-z_]\w*)"),
+    _p("enum", r"^\s*(?:pub\s+)?enum\s+([A-Za-z_]\w*)"),
+    _p("trait", r"^\s*(?:pub\s+)?trait\s+([A-Za-z_]\w*)"),
+    _p("type", r"^\s*(?:pub\s+)?type\s+([A-Za-z_]\w*)"),
+    _p("import", r"^\s*use\s+([^;]+);"),
+]
+
+_JVM_PATTERNS = [
+    _p("class", r"^\s*(?:public\s+|private\s+|protected\s+|abstract\s+|final\s+)*class\s+([A-Za-z_]\w*)"),
+    _p("interface", r"^\s*(?:public\s+)?interface\s+([A-Za-z_]\w*)"),
+    _p("enum", r"^\s*(?:public\s+)?enum\s+([A-Za-z_]\w*)"),
+    _p("import", r"^\s*import\s+([A-Za-z_][\w.*]+)\s*;"),
+    _p("method", r"^\s*(?:public|private|protected|static|final|async|virtual|override|synchronized|native|abstract|\s)+\s+[\w<>,.?\[\]]+\s+([A-Za-z_]\w*)\s*\("),
+]
+
+_C_PATTERNS = [
+    _p("type", r"^\s*(?:typedef\s+)?(?:struct|enum|union)\s+([A-Za-z_]\w*)"),
+    _p("class", r"^\s*class\s+([A-Za-z_]\w*)"),
+    _p("function", r"^\s*[A-Za-z_][\w\s:*&<>]*\s+([A-Za-z_]\w*)\s*\([^;\n]*\)\s*\{"),
+    _p("import", r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]"),
+]
+
+_PHP_PATTERNS = [
+    _p("class", r"^\s*(?:final\s+|abstract\s+)?class\s+([A-Za-z_]\w*)"),
+    _p("interface", r"^\s*interface\s+([A-Za-z_]\w*)"),
+    _p("trait", r"^\s*trait\s+([A-Za-z_]\w*)"),
+    _p("function", r"^\s*(?:public\s+|private\s+|protected\s+|static\s+)*function\s+([A-Za-z_]\w*)"),
+    _p("import", r"^\s*use\s+([^;]+);"),
+]
+
+_RUBY_PATTERNS = [
+    _p("class", r"^\s*class\s+([A-Z]\w*(?:::\w+)*)"),
+    _p("module", r"^\s*module\s+([A-Z]\w*(?:::\w+)*)"),
+    _p("method", r"^\s*def\s+(?:self\.)?([A-Za-z_]\w*[!?=]?)"),
+    _p("import", r"^\s*require(?:_relative)?\s+[\"']([^\"']+)[\"']"),
+]
+
+
+class SymbolProviderRegistry:
+    def __init__(self) -> None:
+        providers: list[SymbolProvider] = [
+            PythonProvider(),
+            RegexProvider("javascript", (".js", ".jsx", ".mjs", ".cjs"), _JS_PATTERNS),
+            RegexProvider("typescript", (".ts", ".tsx", ".mts", ".cts"), _JS_PATTERNS),
+            RegexProvider("go", (".go",), _GO_PATTERNS),
+            RegexProvider("rust", (".rs",), _RUST_PATTERNS),
+            RegexProvider("java", (".java",), _JVM_PATTERNS),
+            RegexProvider("csharp", (".cs",), _JVM_PATTERNS),
+            RegexProvider("c_cpp", (".c", ".h", ".cc", ".cpp", ".cxx", ".hpp"), _C_PATTERNS),
+            RegexProvider("php", (".php",), _PHP_PATTERNS),
+            RegexProvider("ruby", (".rb",), _RUBY_PATTERNS),
+        ]
+        self._by_suffix = {
+            suffix: provider
+            for provider in providers
+            for suffix in provider.suffixes
+        }
+
+    @property
+    def suffixes(self) -> frozenset[str]:
+        return frozenset(self._by_suffix)
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix.lower() in self._by_suffix
+
+    def extract(self, path: Path, source: str) -> list[SymbolRecord]:
+        provider = self._by_suffix.get(path.suffix.lower())
+        if provider is None:
+            return []
+        return provider.extract(path, source)

codecortex/telemetry/__init__.py

@@ -0,0 +1,5 @@
+"""Internal telemetry primitives."""
+
+from codecortex.telemetry.collector import TelemetryCollector
+
+__all__ = ["TelemetryCollector"]

codecortex/telemetry/collector.py

@@ -0,0 +1,43 @@
+"""Telemetry collection with optional local persistence."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from time import time
+from typing import Any
+
+
+@dataclass(slots=True)
+class TelemetryEvent:
+    name: str
+    timestamp: float = field(default_factory=time)
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+class TelemetryCollector:
+    def __init__(self, enabled: bool = True, log_path: Path | None = None) -> None:
+        self.enabled = enabled
+        self.log_path = log_path
+        self._events: list[TelemetryEvent] = []
+        if self.log_path is not None:
+            self.log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def emit(self, name: str, **attributes: Any) -> None:
+        if not self.enabled:
+            return
+        event = TelemetryEvent(name=name, attributes=attributes)
+        self._events.append(event)
+        if self.log_path is not None:
+            with self.log_path.open("a", encoding="utf-8") as handle:
+                handle.write(json.dumps(asdict(event), ensure_ascii=False, default=str) + "\n")
+
+    def events(self) -> list[TelemetryEvent]:
+        return list(self._events)
+
+    def snapshot(self) -> dict[str, int]:
+        counts: dict[str, int] = {}
+        for event in self._events:
+            counts[event.name] = counts.get(event.name, 0) + 1
+        return counts

codecortex/tracing/__init__.py

@@ -0,0 +1,9 @@
+"""Agent task tracing and observability."""
+
+from codecortex.tracing.task_trace import (
+    SpanRecord,
+    TaskTraceRecorder,
+    TraceSummary,
+)
+
+__all__ = ["SpanRecord", "TaskTraceRecorder", "TraceSummary"]

codecortex/tracing/task_trace.py

@@ -0,0 +1,235 @@
+"""Crash-tolerant task traces for agent workflows and tool execution."""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+import uuid
+from collections.abc import AsyncIterator, Iterator
+from contextlib import asynccontextmanager, contextmanager
+from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+_SENSITIVE = re.compile(
+    r"^(?:secret|password|passwd|api[_-]?key|authorization|cookie|token)$"
+    r"|(?:^|[_-])(?:access|refresh|auth)[_-]?token(?:$|[_-])",
+    re.I,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class SpanRecord:
+    trace_id: str
+    span_id: str
+    parent_id: str | None
+    name: str
+    status: str
+    started_at: str
+    ended_at: str
+    duration_ms: float
+    attributes: dict[str, Any]
+    error: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class TraceSummary:
+    trace_id: str
+    spans: int
+    errors: int
+    duration_ms: float
+    tool_calls: int
+    context_tokens: int
+    names: tuple[str, ...]
+
+
+class TaskTraceRecorder:
+    VERSION = 1
+
+    def __init__(self, path: Path, max_attribute_chars: int = 2_000) -> None:
+        self.path = path
+        self.max_attribute_chars = max_attribute_chars
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def new_trace_id(self) -> str:
+        return uuid.uuid4().hex
+
+    @contextmanager
+    def span(
+        self,
+        name: str,
+        *,
+        trace_id: str | None = None,
+        parent_id: str | None = None,
+        attributes: dict[str, Any] | None = None,
+    ) -> Iterator[str]:
+        resolved_trace = trace_id or self.new_trace_id()
+        span_id = uuid.uuid4().hex
+        started_wall = datetime.now(UTC).isoformat()
+        started = time.perf_counter()
+        error: str | None = None
+        status = "ok"
+        try:
+            yield span_id
+        except Exception as exc:
+            status = "error"
+            error = f"{type(exc).__name__}: {exc}"[:500]
+            raise
+        finally:
+            self._append(
+                SpanRecord(
+                    trace_id=resolved_trace,
+                    span_id=span_id,
+                    parent_id=parent_id,
+                    name=name,
+                    status=status,
+                    started_at=started_wall,
+                    ended_at=datetime.now(UTC).isoformat(),
+                    duration_ms=(time.perf_counter() - started) * 1000,
+                    attributes=self._sanitize(attributes or {}),
+                    error=error,
+                )
+            )
+
+    @asynccontextmanager
+    async def async_span(
+        self,
+        name: str,
+        *,
+        trace_id: str | None = None,
+        parent_id: str | None = None,
+        attributes: dict[str, Any] | None = None,
+    ) -> AsyncIterator[str]:
+        resolved_trace = trace_id or self.new_trace_id()
+        span_id = uuid.uuid4().hex
+        started_wall = datetime.now(UTC).isoformat()
+        started = time.perf_counter()
+        error: str | None = None
+        status = "ok"
+        try:
+            yield span_id
+        except Exception as exc:
+            status = "error"
+            error = f"{type(exc).__name__}: {exc}"[:500]
+            raise
+        finally:
+            self._append(
+                SpanRecord(
+                    trace_id=resolved_trace,
+                    span_id=span_id,
+                    parent_id=parent_id,
+                    name=name,
+                    status=status,
+                    started_at=started_wall,
+                    ended_at=datetime.now(UTC).isoformat(),
+                    duration_ms=(time.perf_counter() - started) * 1000,
+                    attributes=self._sanitize(attributes or {}),
+                    error=error,
+                )
+            )
+
+    def record(
+        self,
+        name: str,
+        *,
+        trace_id: str,
+        attributes: dict[str, Any] | None = None,
+        parent_id: str | None = None,
+    ) -> str:
+        now = datetime.now(UTC).isoformat()
+        span_id = uuid.uuid4().hex
+        self._append(
+            SpanRecord(
+                trace_id=trace_id,
+                span_id=span_id,
+                parent_id=parent_id,
+                name=name,
+                status="ok",
+                started_at=now,
+                ended_at=now,
+                duration_ms=0.0,
+                attributes=self._sanitize(attributes or {}),
+            )
+        )
+        return span_id
+
+    def read(self, trace_id: str | None = None, limit: int = 10_000) -> list[SpanRecord]:
+        try:
+            lines = self.path.read_text(encoding="utf-8").splitlines()
+        except OSError:
+            return []
+        records: list[SpanRecord] = []
+        for line in lines[-max(1, limit) :]:
+            try:
+                payload = json.loads(line)
+                if int(payload.get("version", -1)) != self.VERSION:
+                    continue
+                data = payload["span"]
+                record = SpanRecord(
+                    trace_id=str(data["trace_id"]),
+                    span_id=str(data["span_id"]),
+                    parent_id=str(data["parent_id"]) if data.get("parent_id") else None,
+                    name=str(data["name"]),
+                    status=str(data["status"]),
+                    started_at=str(data["started_at"]),
+                    ended_at=str(data["ended_at"]),
+                    duration_ms=float(data["duration_ms"]),
+                    attributes=dict(data.get("attributes", {})),
+                    error=str(data["error"]) if data.get("error") else None,
+                )
+            except (json.JSONDecodeError, KeyError, TypeError, ValueError):
+                continue
+            if trace_id is None or record.trace_id == trace_id:
+                records.append(record)
+        return records
+
+    def summarize(self, trace_id: str) -> TraceSummary:
+        records = self.read(trace_id)
+        return TraceSummary(
+            trace_id=trace_id,
+            spans=len(records),
+            errors=sum(record.status == "error" for record in records),
+            duration_ms=sum(record.duration_ms for record in records),
+            tool_calls=sum(record.name.startswith("tool.") for record in records),
+            context_tokens=sum(
+                self._integer_metric(record.attributes.get("context_tokens"))
+                for record in records
+            ),
+            names=tuple(record.name for record in records),
+        )
+
+    def _append(self, record: SpanRecord) -> None:
+        payload = {"version": self.VERSION, "span": asdict(record)}
+        with self.path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+            handle.write("\n")
+            handle.flush()
+
+    def _sanitize(self, attributes: dict[str, Any]) -> dict[str, Any]:
+        sanitized: dict[str, Any] = {}
+        for key, value in attributes.items():
+            if _SENSITIVE.search(str(key)):
+                sanitized[str(key)] = "[REDACTED]"
+                continue
+            if isinstance(value, (str, int, float, bool)) or value is None:
+                text = value if not isinstance(value, str) else value[: self.max_attribute_chars]
+                sanitized[str(key)] = text
+            else:
+                serialized = json.dumps(value, ensure_ascii=False, default=str)
+                sanitized[str(key)] = serialized[: self.max_attribute_chars]
+        return sanitized
+
+    @staticmethod
+    def _integer_metric(value: Any) -> int:
+        if isinstance(value, bool):
+            return int(value)
+        if isinstance(value, (int, float)):
+            return int(value)
+        if isinstance(value, str):
+            try:
+                return int(float(value))
+            except ValueError:
+                return 0
+        return 0

codecortex/workspace/__init__.py

@@ -0,0 +1,9 @@
+"""Multi-repository workspaces."""
+
+from codecortex.workspace.federation import (
+    FederatedHit,
+    MultiRepositoryWorkspace,
+    RepositoryDescriptor,
+)
+
+__all__ = ["FederatedHit", "MultiRepositoryWorkspace", "RepositoryDescriptor"]