anywhere-cli 0.1.0__py3-none-any.whl

connector/claude/normalizers.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any
+
+from connector.claude.normalized import NormalizedClaudeEvent
+
+
+class ClaudeLiveNormalizer:
+    def normalize(self, raw_events: list[dict[str, Any]]) -> list[NormalizedClaudeEvent]:
+        return [_event for raw in raw_events for _event in _normalize_raw(raw)]
+
+
+class ClaudeTranscriptNormalizer:
+    def normalize(self, raw_entries: list[dict[str, Any]]) -> list[NormalizedClaudeEvent]:
+        return [_event for raw in raw_entries for _event in _normalize_raw(raw)]
+
+
+def _normalize_raw(raw: dict[str, Any]) -> list[NormalizedClaudeEvent]:
+    message = raw.get("message") if isinstance(raw.get("message"), dict) else raw
+    claude_session_id = _string(raw.get("session_id") or raw.get("sessionId") or raw.get("uuid")) or "unknown"
+    source_event_id = _string(raw.get("uuid") or raw.get("id") or message.get("id")) or "unknown"
+    message_id = _string(message.get("id") or raw.get("message_id") or raw.get("messageId"))
+    role = _string(message.get("role") or raw.get("role"))
+    timestamp = _string(raw.get("timestamp") or message.get("timestamp"))
+    content = message.get("content")
+    if not isinstance(content, list):
+        if isinstance(content, str):
+            return [
+                NormalizedClaudeEvent(
+                    claudeSessionId=claude_session_id,
+                    sourceEventId=source_event_id,
+                    messageId=message_id,
+                    role=role if role in {"user", "assistant", "tool", "system"} else None,
+                    blockIndex=0,
+                    blockType="text",
+                    text=content,
+                    timestamp=timestamp,
+                )
+            ]
+        return []
+
+    normalized: list[NormalizedClaudeEvent] = []
+    for index, block in enumerate(content):
+        if not isinstance(block, dict):
+            continue
+        block_type = _string(block.get("type")) or "unknown"
+        if block_type == "text":
+            text = _string(block.get("text"))
+            if text is not None and text.strip():
+                normalized.append(
+                    NormalizedClaudeEvent(
+                        claudeSessionId=claude_session_id,
+                        sourceEventId=f"{source_event_id}:{index}",
+                        messageId=message_id,
+                        role=role if role in {"user", "assistant", "tool", "system"} else None,
+                        blockIndex=index,
+                        blockType=block_type,
+                        text=text,
+                        timestamp=timestamp,
+                    )
+                )
+        elif block_type == "tool_use":
+            normalized.append(
+                NormalizedClaudeEvent(
+                    claudeSessionId=claude_session_id,
+                    sourceEventId=f"{source_event_id}:{index}",
+                    messageId=message_id,
+                    role="assistant",
+                    blockIndex=index,
+                    blockType=block_type,
+                    toolUseId=_string(block.get("id")),
+                    toolName=_string(block.get("name")),
+                    toolInput=block.get("input"),
+                    timestamp=timestamp,
+                )
+            )
+        elif block_type == "tool_result":
+            normalized.append(
+                NormalizedClaudeEvent(
+                    claudeSessionId=claude_session_id,
+                    sourceEventId=f"{source_event_id}:{index}",
+                    messageId=message_id,
+                    role="tool",
+                    blockIndex=index,
+                    blockType=block_type,
+                    toolUseId=_string(block.get("tool_use_id")),
+                    toolResult=block.get("content"),
+                    toolResultIsError=block.get("is_error") if isinstance(block.get("is_error"), bool) else None,
+                    text=_string(block.get("content")),
+                    timestamp=timestamp,
+                )
+            )
+    return normalized
+
+
+def _string(value: Any) -> str | None:
+    return value if isinstance(value, str) else None

connector/claude/path_utils.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import hashlib
+
+
+def stable_claude_session_id(connector_id: str, claude_uuid: str) -> str:
+    """Deterministic session_id derived from (connector, claude session uuid).
+
+    Mirrors connector.codex.adapter.stable_session_id so the backend never
+    sees two ids referring to the same upstream session.
+    """
+    digest = hashlib.sha256(f"{connector_id}:claude:{claude_uuid}".encode("utf-8")).hexdigest()[:24]
+    return f"sess_claude_{digest}"

connector/claude/preferences.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from connector.time import utc_now
+
+
+def _settings_path() -> Path:
+    return Path.home() / ".claude" / "settings.json"
+
+
+def read_local_preferences(path: Path | None = None) -> dict[str, Any]:
+    """Read the user's ~/.claude/settings.json and surface the fields the
+    backend cares about. Returns an empty dict if the file is missing or
+    unreadable; missing fields surface as None so the frontend can fall back
+    to the seeded `is_default` choice.
+
+    Shape mirrors what `connector.preferencesUpdated` puts on the wire.
+    """
+    target = path or _settings_path()
+    if not target.exists():
+        return {}
+    try:
+        data = json.loads(target.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    permissions = data.get("permissions")
+    permission_mode = permissions.get("defaultMode") if isinstance(permissions, dict) else None
+    return {
+        "permissionMode": permission_mode if isinstance(permission_mode, str) else None,
+        "model": data.get("model") if isinstance(data.get("model"), str) else None,
+        "effort": data.get("effort") if isinstance(data.get("effort"), str) else None,
+        "readAt": utc_now(),
+    }