axion-code 1.0.0__py3-none-any.whl

axion/telemetry/events.py

@@ -0,0 +1,67 @@
+"""Telemetry event types.
+
+Maps to: rust/crates/telemetry/src/lib.rs (event types)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class AnalyticsEvent:
+    """User action event."""
+
+    namespace: str
+    action: str
+    properties: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class HttpRequestStarted:
+    session_id: str
+    attempt: int
+    method: str
+    path: str
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class HttpRequestSucceeded:
+    session_id: str
+    attempt: int
+    method: str
+    path: str
+    status: int
+    request_id: str | None = None
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class HttpRequestFailed:
+    session_id: str
+    attempt: int
+    method: str
+    path: str
+    error: str
+    retryable: bool = False
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class SessionTraceRecord:
+    session_id: str
+    sequence: int
+    name: str
+    timestamp_ms: int
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+TelemetryEvent = (
+    HttpRequestStarted
+    | HttpRequestSucceeded
+    | HttpRequestFailed
+    | AnalyticsEvent
+    | SessionTraceRecord
+)

axion/telemetry/profile.py

@@ -0,0 +1,49 @@
+"""Anthropic request profile and client identity.
+
+Maps to: rust/crates/telemetry/src/lib.rs (AnthropicRequestProfile, ClientIdentity)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+DEFAULT_ANTHROPIC_VERSION = "2023-06-01"
+DEFAULT_APP_NAME = "axion-code"
+DEFAULT_RUNTIME = "python"
+DEFAULT_AGENTIC_BETA = "claude-code-20250219"
+DEFAULT_PROMPT_CACHING_SCOPE_BETA = "prompt-caching-scope-2026-01-05"
+
+
+@dataclass
+class ClientIdentity:
+    """Application identity for API requests."""
+
+    app_name: str = DEFAULT_APP_NAME
+    app_version: str = "1.0.0"
+    runtime: str = DEFAULT_RUNTIME
+
+    def user_agent(self) -> str:
+        return f"{self.app_name}/{self.app_version}"
+
+
+@dataclass
+class AnthropicRequestProfile:
+    """HTTP request configuration for Anthropic API."""
+
+    anthropic_version: str = DEFAULT_ANTHROPIC_VERSION
+    client_identity: ClientIdentity = field(default_factory=ClientIdentity)
+    betas: list[str] = field(
+        default_factory=lambda: [DEFAULT_AGENTIC_BETA, DEFAULT_PROMPT_CACHING_SCOPE_BETA]
+    )
+    extra_body: dict[str, Any] = field(default_factory=dict)
+
+    def header_pairs(self) -> dict[str, str]:
+        """Generate HTTP headers for the request."""
+        headers = {
+            "anthropic-version": self.anthropic_version,
+            "user-agent": self.client_identity.user_agent(),
+        }
+        if self.betas:
+            headers["anthropic-beta"] = ",".join(self.betas)
+        return headers

axion/telemetry/sink.py

@@ -0,0 +1,60 @@
+"""Telemetry sinks for event recording.
+
+Maps to: rust/crates/telemetry/src/lib.rs (TelemetrySink)
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+from axion.telemetry.events import TelemetryEvent
+
+
+@runtime_checkable
+class TelemetrySink(Protocol):
+    """Protocol for recording telemetry events."""
+
+    def record(self, event: TelemetryEvent) -> None: ...
+
+
+class MemoryTelemetrySink:
+    """In-memory telemetry sink for testing."""
+
+    def __init__(self) -> None:
+        self._events: list[TelemetryEvent] = []
+        self._lock = threading.Lock()
+
+    def record(self, event: TelemetryEvent) -> None:
+        with self._lock:
+            self._events.append(event)
+
+    def events(self) -> list[TelemetryEvent]:
+        with self._lock:
+            return list(self._events)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._events.clear()
+
+
+class JsonlTelemetrySink:
+    """JSONL file-based telemetry sink."""
+
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._lock = threading.Lock()
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    def record(self, event: TelemetryEvent) -> None:
+        with self._lock:
+            with open(self._path, "a", encoding="utf-8") as f:
+                # Simple serialization
+                data: dict[str, Any] = {
+                    "type": type(event).__name__,
+                }
+                for k, v in vars(event).items():
+                    data[k] = v
+                f.write(json.dumps(data, default=str) + "\n")

axion/telemetry/tracer.py

@@ -0,0 +1,95 @@
+"""Session-level event tracer.
+
+Maps to: rust/crates/telemetry/src/lib.rs (SessionTracer)
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any
+
+from axion.telemetry.events import (
+    AnalyticsEvent,
+    HttpRequestFailed,
+    HttpRequestStarted,
+    HttpRequestSucceeded,
+    SessionTraceRecord,
+)
+from axion.telemetry.sink import TelemetrySink
+
+
+class SessionTracer:
+    """Session-level event recorder with atomic sequence counter.
+
+    Maps to: rust/crates/telemetry/src/lib.rs::SessionTracer
+    """
+
+    def __init__(self, session_id: str, sink: TelemetrySink) -> None:
+        self.session_id = session_id
+        self._sink = sink
+        self._sequence = 0
+        self._lock = threading.Lock()
+
+    def _next_seq(self) -> int:
+        with self._lock:
+            self._sequence += 1
+            return self._sequence
+
+    def record(self, name: str, attributes: dict[str, Any] | None = None) -> None:
+        """Record a session trace event."""
+        event = SessionTraceRecord(
+            session_id=self.session_id,
+            sequence=self._next_seq(),
+            name=name,
+            timestamp_ms=int(time.time() * 1000),
+            attributes=attributes or {},
+        )
+        self._sink.record(event)
+
+    def record_http_request_started(
+        self, attempt: int, method: str, path: str
+    ) -> None:
+        self._sink.record(HttpRequestStarted(
+            session_id=self.session_id,
+            attempt=attempt,
+            method=method,
+            path=path,
+        ))
+
+    def record_http_request_succeeded(
+        self,
+        attempt: int,
+        method: str,
+        path: str,
+        status: int,
+        request_id: str | None = None,
+    ) -> None:
+        self._sink.record(HttpRequestSucceeded(
+            session_id=self.session_id,
+            attempt=attempt,
+            method=method,
+            path=path,
+            status=status,
+            request_id=request_id,
+        ))
+
+    def record_http_request_failed(
+        self,
+        attempt: int,
+        method: str,
+        path: str,
+        error: str,
+        retryable: bool = False,
+    ) -> None:
+        self._sink.record(HttpRequestFailed(
+            session_id=self.session_id,
+            attempt=attempt,
+            method=method,
+            path=path,
+            error=error,
+            retryable=retryable,
+        ))
+
+    def record_analytics(self, event: AnalyticsEvent) -> None:
+        self._sink.record(event)

axion/tools/lane_completion.py

@@ -0,0 +1,33 @@
+"""Lane completion tools.
+
+Maps to: rust/crates/tools/src/lane_completion.rs
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class LaneCompletionResult:
+    lane_id: str
+    status: str
+    message: str = ""
+
+
+def complete_lane(lane_id: str) -> LaneCompletionResult:
+    """Mark a lane as completed."""
+    return LaneCompletionResult(
+        lane_id=lane_id,
+        status="completed",
+        message=f"Lane {lane_id} marked as completed",
+    )
+
+
+def reconcile_lane(lane_id: str) -> LaneCompletionResult:
+    """Mark a lane as reconciled."""
+    return LaneCompletionResult(
+        lane_id=lane_id,
+        status="reconciled",
+        message=f"Lane {lane_id} reconciled",
+    )