promty-collector 0.1.0

package/src/config.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+DEFAULT_CONFIG_PATH = Path(
+    os.environ.get("PROMPTHUB_CONFIG_PATH", "~/.prompthub/config.json")
+).expanduser()
+DEFAULT_APP_URL = os.environ.get("PROMPTHUB_APP_URL", "http://127.0.0.1:5173")
+DEFAULT_API_URL = os.environ.get("PROMPTHUB_API_URL", "http://127.0.0.1:8011")
+DEFAULT_UPLOADER_PID_PATH = Path(
+    os.environ.get("PROMPTHUB_UPLOADER_PID_PATH", "~/.prompthub/uploader.pid")
+).expanduser()
+DEFAULT_UPLOADER_LOG_PATH = Path(
+    os.environ.get("PROMPTHUB_UPLOADER_LOG_PATH", "~/.prompthub/uploader.log")
+).expanduser()
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def config_path(path: str | Path | None = None) -> Path:
+    return Path(path).expanduser() if path else DEFAULT_CONFIG_PATH
+
+
+def read_config(path: str | Path | None = None) -> dict[str, Any]:
+    target = config_path(path)
+    if not target.exists():
+        return {}
+
+    try:
+        with target.open("r", encoding="utf-8") as file:
+            payload = json.load(file)
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+    return payload if isinstance(payload, dict) else {}
+
+
+def write_config(values: dict[str, Any], path: str | Path | None = None) -> dict[str, Any]:
+    target = config_path(path)
+    existing = read_config(target)
+    merged = {**existing, **values, "updated_at": utc_now_iso()}
+    target.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = target.with_suffix(f"{target.suffix}.{uuid4()}.tmp")
+    with tmp_path.open("w", encoding="utf-8") as file:
+        json.dump(merged, file, ensure_ascii=False, indent=2, sort_keys=True)
+        file.write("\n")
+    tmp_path.replace(target)
+    try:
+        target.chmod(0o600)
+    except OSError:
+        pass
+    return merged
+
+
+def resolve_app_url(value: str | None = None, path: str | Path | None = None) -> str:
+    if value:
+        return value.rstrip("/")
+    if os.environ.get("PROMPTHUB_APP_URL"):
+        return os.environ["PROMPTHUB_APP_URL"].rstrip("/")
+    configured = read_config(path).get("app_url")
+    if isinstance(configured, str) and configured.strip():
+        return configured.rstrip("/")
+    return DEFAULT_APP_URL.rstrip("/")
+
+
+def resolve_api_url(value: str | None = None, path: str | Path | None = None) -> str:
+    if value:
+        return value.rstrip("/")
+    if os.environ.get("PROMPTHUB_API_URL"):
+        return os.environ["PROMPTHUB_API_URL"].rstrip("/")
+    configured = read_config(path).get("api_url")
+    if isinstance(configured, str) and configured.strip():
+        return configured.rstrip("/")
+    return DEFAULT_API_URL.rstrip("/")
+
+
+def resolve_token(value: str | None = None, path: str | Path | None = None) -> str | None:
+    if value:
+        return value
+    if os.environ.get("PROMPTHUB_API_TOKEN"):
+        return os.environ["PROMPTHUB_API_TOKEN"]
+    configured = read_config(path).get("token")
+    return configured if isinstance(configured, str) and configured.strip() else None

package/src/events.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+import os
+from pathlib import Path
+from typing import Any, Literal
+from uuid import NAMESPACE_DNS, UUID, uuid4, uuid5
+
+SupportedTool = Literal["claude-code", "codex-cli", "cursor", "gemini-cli"]
+EventType = Literal[
+    "SessionStarted",
+    "PromptSubmitted",
+    "ResponseReceived",
+    "FilesChanged",
+    "CommitCreated",
+    "SessionEnded",
+]
+
+SUPPORTED_TOOLS: tuple[SupportedTool, ...] = (
+    "claude-code",
+    "codex-cli",
+    "cursor",
+    "gemini-cli",
+)
+SUPPORTED_EVENT_TYPES: tuple[EventType, ...] = (
+    "SessionStarted",
+    "PromptSubmitted",
+    "ResponseReceived",
+    "FilesChanged",
+    "CommitCreated",
+    "SessionEnded",
+)
+EVENT_TYPE_ALIASES: dict[str, EventType] = {
+    "SessionStart": "SessionStarted",
+    "SessionEnd": "SessionEnded",
+    "Stop": "ResponseReceived",
+    "SESSION_STARTED": "SessionStarted",
+    "PROMPT_SENT": "PromptSubmitted",
+    "PROMPT_RESPONSE": "ResponseReceived",
+    "FILES_CHANGED": "FilesChanged",
+    "COMMIT_CREATED": "CommitCreated",
+    "SESSION_ENDED": "SessionEnded",
+    "session_started": "SessionStarted",
+    "prompt_sent": "PromptSubmitted",
+    "prompt_submitted": "PromptSubmitted",
+    "response_received": "ResponseReceived",
+    "prompt_response": "ResponseReceived",
+    "files_changed": "FilesChanged",
+    "commit_created": "CommitCreated",
+    "session_ended": "SessionEnded",
+}
+
+TOOL_ALIASES: dict[str, SupportedTool] = {
+    "claude": "claude-code",
+    "claude-code": "claude-code",
+    "codex": "codex-cli",
+    "codex-cli": "codex-cli",
+    "cursor": "cursor",
+    "gemini": "gemini-cli",
+    "gemini-cli": "gemini-cli",
+}
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass(slots=True)
+class PayloadBase:
+    def to_dict(self) -> dict[str, Any]:
+        return {key: value for key, value in asdict(self).items() if value is not None}
+
+
+@dataclass(slots=True)
+class SessionStartedPayload(PayloadBase):
+    cwd: str | None = None
+    branch: str | None = None
+    git_remote: str | None = None
+    github_url: str | None = None
+    model: str | None = None
+    permission_mode: str | None = None
+    session_id: str | None = None
+
+
+@dataclass(slots=True)
+class PromptSubmittedPayload(PayloadBase):
+    prompt: str
+    cwd: str | None = None
+    model: str | None = None
+    permission_mode: str | None = None
+    transcript_path: str | None = None
+    turn_id: str | int | None = None
+    session_id: str | None = None
+    branch: str | None = None
+    git_remote: str | None = None
+    github_url: str | None = None
+    hook_event_name: str | None = None
+    approval_policy: str | None = None
+    sandbox_mode: str | None = None
+
+
+@dataclass(slots=True)
+class ResponseReceivedPayload(PayloadBase):
+    response: str | None = None
+    response_truncated: bool = False
+    response_original_length: int | None = None
+    response_storage_limit: int | None = None
+    response_source: str | None = None
+    transcript_path: str | None = None
+    turn_id: str | int | None = None
+    duration_ms: int | None = None
+    success: bool | None = None
+    model: str | None = None
+    session_id: str | None = None
+
+
+@dataclass(slots=True)
+class FilesChangedPayload(PayloadBase):
+    files: list[str] = field(default_factory=list)
+    cwd: str | None = None
+    session_id: str | None = None
+    prompt_event_id: str | None = None
+    turn_id: str | int | None = None
+    git_root: str | None = None
+    branch: str | None = None
+    git_remote: str | None = None
+    github_url: str | None = None
+    base_commit: str | None = None
+    head_commit: str | None = None
+    baseline_captured_at: str | None = None
+    detected_at: str | None = None
+    source: str | None = None
+    summary: dict[str, Any] | None = None
+    changes: list[dict[str, Any]] = field(default_factory=list)
+    change_detection_complete: bool | None = None
+    no_changes: bool | None = None
+
+
+@dataclass(slots=True)
+class CommitCreatedPayload(PayloadBase):
+    hash: str | None = None
+    message: str | None = None
+    branch: str | None = None
+    git_remote: str | None = None
+    github_url: str | None = None
+    cwd: str | None = None
+    session_id: str | None = None
+
+
+@dataclass(slots=True)
+class SessionEndedPayload(PayloadBase):
+    reason: str | None = None
+    duration: int | None = None
+    session_id: str | None = None
+
+
+EventPayload = (
+    SessionStartedPayload
+    | PromptSubmittedPayload
+    | ResponseReceivedPayload
+    | FilesChangedPayload
+    | CommitCreatedPayload
+    | SessionEndedPayload
+)
+
+
+@dataclass(slots=True)
+class BaseEvent:
+    tool: SupportedTool
+    event_type: EventType
+    payload: EventPayload
+    project_id: str
+    session_id: str
+    sequence: int
+    id: str = field(default_factory=lambda: str(uuid4()))
+    timestamp: str = field(default_factory=utc_now_iso)
+    schema_version: int = 1
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "schema_version": self.schema_version,
+            "project_id": self.project_id,
+            "session_id": self.session_id,
+            "sequence": self.sequence,
+            "tool": self.tool,
+            "event_type": self.event_type,
+            "timestamp": self.timestamp,
+            "payload": self.payload.to_dict(),
+        }
+
+
+def normalize_tool(tool: str) -> SupportedTool:
+    normalized = TOOL_ALIASES.get(tool)
+    if normalized is None:
+        raise ValueError(f"Unsupported tool: {tool}")
+    return normalized
+
+
+def normalize_event_type(event_type: str) -> EventType:
+    if event_type not in SUPPORTED_EVENT_TYPES:
+        alias = EVENT_TYPE_ALIASES.get(event_type)
+        if alias:
+            return alias
+        raise ValueError(f"Unsupported event type: {event_type}")
+    return event_type  # type: ignore[return-value]
+
+
+def coerce_uuid(value: Any) -> str | None:
+    if value is None:
+        return None
+    try:
+        return str(UUID(str(value)))
+    except ValueError:
+        return None
+
+
+def stable_uuid(namespace_name: str, value: Any) -> str:
+    namespace = uuid5(NAMESPACE_DNS, namespace_name)
+    return str(uuid5(namespace, str(value)))
+
+
+def find_project_root(path_value: Any) -> str:
+    path = Path(str(path_value)).expanduser()
+    if not path.exists():
+        return str(path_value)
+    try:
+        candidate = path if path.is_dir() else path.parent
+        candidate = candidate.resolve()
+    except OSError:
+        return str(path_value)
+
+    for current in (candidate, *candidate.parents):
+        if (current / ".git").exists():
+            return str(current)
+    return str(candidate)
+
+
+def resolve_project_id(raw_payload: dict[str, Any], event_payload: dict[str, Any]) -> str:
+    explicit_project_id = (
+        coerce_uuid(raw_payload.get("project_id"))
+        or coerce_uuid(event_payload.get("project_id"))
+        or coerce_uuid(os.environ.get("PROMPTHUB_PROJECT_ID"))
+    )
+    if explicit_project_id:
+        return explicit_project_id
+
+    project_seed = (
+        event_payload.get("cwd")
+        or raw_payload.get("cwd")
+        or raw_payload.get("workspace")
+        or os.getcwd()
+    )
+    return stable_uuid("prompthub.project", find_project_root(project_seed))
+
+
+def resolve_session_id(
+    tool: SupportedTool,
+    project_id: str,
+    raw_payload: dict[str, Any],
+    event_payload: dict[str, Any],
+) -> str:
+    explicit_session_id = (
+        coerce_uuid(raw_payload.get("session_id"))
+        or coerce_uuid(event_payload.get("session_id"))
+        or coerce_uuid(os.environ.get("PROMPTHUB_SESSION_ID"))
+    )
+    if explicit_session_id:
+        return explicit_session_id
+
+    session_seed = (
+        raw_payload.get("session_id")
+        or raw_payload.get("conversation_id")
+        or raw_payload.get("thread_id")
+        or event_payload.get("session_id")
+        or f"{project_id}:{tool}"
+    )
+    return stable_uuid("prompthub.session", f"{project_id}:{tool}:{session_seed}")
+
+
+def resolve_sequence(raw_payload: dict[str, Any], event_payload: dict[str, Any]) -> int:
+    for key in ("sequence", "seq", "turn_id", "turn", "message_index"):
+        value = raw_payload.get(key)
+        if value is None:
+            value = event_payload.get(key)
+        if isinstance(value, int) and value > 0:
+            return value
+        if isinstance(value, str) and value.isdigit():
+            return int(value)
+    return 0
+
+
+def build_event(
+    *,
+    tool: SupportedTool,
+    event_type: EventType,
+    payload: EventPayload,
+    raw_payload: dict[str, Any],
+) -> BaseEvent:
+    event_payload = payload.to_dict()
+    project_id = resolve_project_id(raw_payload, event_payload)
+    session_id = resolve_session_id(tool, project_id, raw_payload, event_payload)
+    sequence = resolve_sequence(raw_payload, event_payload)
+
+    return BaseEvent(
+        project_id=project_id,
+        session_id=session_id,
+        sequence=sequence,
+        tool=tool,
+        event_type=event_type,
+        payload=payload,
+    )

package/src/file_lock.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator, TextIO
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - Windows
+    fcntl = None
+
+try:
+    import msvcrt
+except ImportError:  # pragma: no cover - POSIX
+    msvcrt = None
+
+
+@contextmanager
+def locked_file(path: Path) -> Iterator[TextIO]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a+", encoding="utf-8") as lock_file:
+        if fcntl is not None:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+        elif msvcrt is not None:
+            lock_file.seek(0, 2)
+            if lock_file.tell() == 0:
+                lock_file.write("\0")
+                lock_file.flush()
+            lock_file.seek(0)
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_LOCK, 1)
+        try:
+            yield lock_file
+        finally:
+            if fcntl is not None:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+            elif msvcrt is not None:
+                lock_file.seek(0)
+                msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)

package/src/git_context.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import re
+import subprocess
+
+GIT_TIMEOUT_SECONDS = float(os.environ.get("PROMPTHUB_GIT_TIMEOUT", "5"))
+
+
+def _run_git(args: list[str], cwd: str | Path, timeout: float = GIT_TIMEOUT_SECONDS) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=str(cwd),
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip() or None
+
+
+def resolve_git_root(cwd: str | Path | None = None) -> str | None:
+    start = Path(cwd or os.getcwd()).expanduser()
+    output = _run_git(["rev-parse", "--show-toplevel"], start)
+    return output or None
+
+
+def normalize_github_url(remote_url: str | None) -> str | None:
+    if not remote_url:
+        return None
+
+    value = remote_url.strip()
+    patterns = (
+        r"^git@github\.com:(?P<owner>[^/]+)/(?P<repo>[^/]+?)(?:\.git)?$",
+        r"^ssh://git@github\.com/(?P<owner>[^/]+)/(?P<repo>[^/]+?)(?:\.git)?$",
+        r"^https://github\.com/(?P<owner>[^/]+)/(?P<repo>[^/]+?)(?:\.git)?/?$",
+    )
+    for pattern in patterns:
+        match = re.match(pattern, value)
+        if match:
+            return f"https://github.com/{match.group('owner')}/{match.group('repo')}"
+
+    return value if value.startswith("https://github.com/") else None
+
+
+def git_context(cwd: str | Path | None = None) -> dict[str, str]:
+    git_root = resolve_git_root(cwd)
+    if git_root is None:
+        return {}
+
+    remote_url = (
+        _run_git(["remote", "get-url", "origin"], git_root)
+        or _run_git(["config", "--get", "remote.origin.url"], git_root)
+    )
+    branch = _run_git(["branch", "--show-current"], git_root)
+    context = {
+        "git_root": git_root,
+        "branch": branch,
+        "git_remote": remote_url,
+        "github_url": normalize_github_url(remote_url),
+    }
+    return {key: value for key, value in context.items() if value}

package/src/payloads.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+SESSION_ID_KEYS = ("session_id", "conversation_id", "thread_id")
+WORKSPACE_KEYS = ("cwd", "working_directory", "workspace")
+PROJECT_CONTEXT_KEYS = ("project_id", *WORKSPACE_KEYS)
+TURN_ID_KEYS = ("turn_id", "turn", "message_index")
+
+
+def payload_views(payload: Mapping[str, Any]) -> tuple[Mapping[str, Any], ...]:
+    nested_payload = payload.get("payload")
+    if isinstance(nested_payload, Mapping):
+        return nested_payload, payload
+    return (payload,)
+
+
+def get_first_value(payload: Mapping[str, Any], keys: tuple[str, ...]) -> Any:
+    return first_value(payload_views(payload), keys)
+
+
+def get_first_string(payload: Mapping[str, Any], keys: tuple[str, ...]) -> str | None:
+    return first_string(payload_views(payload), keys)
+
+
+def first_value(payloads: tuple[Mapping[str, Any], ...], keys: tuple[str, ...]) -> Any:
+    for payload in payloads:
+        for key in keys:
+            if key in payload and payload[key] is not None:
+                return payload[key]
+    return None
+
+
+def first_string(payloads: tuple[Mapping[str, Any], ...], keys: tuple[str, ...]) -> str | None:
+    value = first_value(payloads, keys)
+    return value if isinstance(value, str) and value else None
+
+
+def first_int(payloads: tuple[Mapping[str, Any], ...], keys: tuple[str, ...]) -> int | None:
+    value = first_value(payloads, keys)
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.isdigit():
+        return int(value)
+    return None
+
+
+def first_bool(payloads: tuple[Mapping[str, Any], ...], keys: tuple[str, ...]) -> bool | None:
+    value = first_value(payloads, keys)
+    return value if isinstance(value, bool) else None
+
+
+def string_list(payloads: tuple[Mapping[str, Any], ...], keys: tuple[str, ...]) -> list[str]:
+    value = first_value(payloads, keys)
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, str)]