risenlab-agentlogs 0.2__tar.gz

risenlab_agentlogs-0.2/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+dist/
+*.egg-info/
+.venv

risenlab_agentlogs-0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RISEN Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

risenlab_agentlogs-0.2/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.5
+Name: risenlab-agentlogs
+Version: 0.2
+Summary: Schema definitions and utilities for the AgentLogs dataset
+Project-URL: Homepage, https://github.com/risenlab/agentlogs
+Project-URL: Documentation, https://github.com/risenlab/agentlogs/tree/main/docs/schema
+Project-URL: Dataset, https://huggingface.co/datasets/risenlab/agentlogs
+Author: RISEN Lab
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agentlogs,copilot,dataset,github,schema
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# AgentLogs
+
+[![version 0.2](https://img.shields.io/badge/version-0.2-blue)](https://huggingface.co/datasets/risenlab/agentlogs/tree/v0.2)
+[![Hugging Face](https://img.shields.io/badge/Hugging%20Face-dataset-ffd21e?logo=huggingface&logoColor=ffd21e)](https://huggingface.co/datasets/risenlab/agentlogs)
+[![GitHub](https://img.shields.io/badge/GitHub-code-black?logo=github)](https://github.com/risenlab/agentlogs)
+
+TypedDict schema and helpers for the [AgentLogs](https://huggingface.co/datasets/risenlab/agentlogs) dataset. Field-level documentation: [schema reference](https://github.com/risenlab/agentlogs/tree/v0.2/docs/schema).
+
+## Installation
+
+```bash
+pip install risenlab-agentlogs huggingface_hub pyarrow
+```
+
+## Usage
+
+```python
+from pathlib import Path
+
+import pyarrow.parquet as pq
+from huggingface_hub import snapshot_download
+from agentlogs.schema import AgentSession, assert_dataset_version, cast_record
+
+# Full dataset into data/dataset/; existing files are skipped
+dataset_path = Path("data") / "dataset"
+snapshot_download(
+    repo_id="risenlab/agentlogs",
+    repo_type="dataset",
+    revision="v0.2",
+    local_dir=dataset_path,
+)
+# Fail if the snapshot tag does not match this package version
+assert_dataset_version(dataset_path)
+
+# First session row, typed as AgentSession (nested fields included)
+session_file = next((dataset_path / "agent_sessions").glob("*.parquet"))
+session = cast_record(
+    AgentSession,
+    pq.read_table(session_file, memory_map=False).slice(0, 1).to_pylist()[0],
+)
+print(session["id"], session["name"])
+```

risenlab_agentlogs-0.2/README.md

@@ -0,0 +1,42 @@
+# AgentLogs
+
+[![version 0.2](https://img.shields.io/badge/version-0.2-blue)](https://huggingface.co/datasets/risenlab/agentlogs/tree/v0.2)
+[![Hugging Face](https://img.shields.io/badge/Hugging%20Face-dataset-ffd21e?logo=huggingface&logoColor=ffd21e)](https://huggingface.co/datasets/risenlab/agentlogs)
+[![GitHub](https://img.shields.io/badge/GitHub-code-black?logo=github)](https://github.com/risenlab/agentlogs)
+
+TypedDict schema and helpers for the [AgentLogs](https://huggingface.co/datasets/risenlab/agentlogs) dataset. Field-level documentation: [schema reference](https://github.com/risenlab/agentlogs/tree/v0.2/docs/schema).
+
+## Installation
+
+```bash
+pip install risenlab-agentlogs huggingface_hub pyarrow
+```
+
+## Usage
+
+```python
+from pathlib import Path
+
+import pyarrow.parquet as pq
+from huggingface_hub import snapshot_download
+from agentlogs.schema import AgentSession, assert_dataset_version, cast_record
+
+# Full dataset into data/dataset/; existing files are skipped
+dataset_path = Path("data") / "dataset"
+snapshot_download(
+    repo_id="risenlab/agentlogs",
+    repo_type="dataset",
+    revision="v0.2",
+    local_dir=dataset_path,
+)
+# Fail if the snapshot tag does not match this package version
+assert_dataset_version(dataset_path)
+
+# First session row, typed as AgentSession (nested fields included)
+session_file = next((dataset_path / "agent_sessions").glob("*.parquet"))
+session = cast_record(
+    AgentSession,
+    pq.read_table(session_file, memory_map=False).slice(0, 1).to_pylist()[0],
+)
+print(session["id"], session["name"])
+```

risenlab_agentlogs-0.2/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "risenlab-agentlogs"
+dynamic = ["version"]
+description = "Schema definitions and utilities for the AgentLogs dataset"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "RISEN Lab" }]
+keywords = ["agentlogs", "github", "copilot", "dataset", "schema"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/risenlab/agentlogs"
+Documentation = "https://github.com/risenlab/agentlogs/tree/main/docs/schema"
+Dataset = "https://huggingface.co/datasets/risenlab/agentlogs"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/agentlogs/schema/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentlogs"]

risenlab_agentlogs-0.2/src/agentlogs/schema/__init__.py

@@ -0,0 +1,91 @@
+__version__ = "0.2"
+
+from pathlib import Path
+
+from .types.agent_session import (
+    AgentSession,
+    AgentSessionUsage,
+    AgentSessionEvent,
+)
+from .types.agent_task import (
+    AgentArtifactReference,
+    AgentTask,
+    AgentTaskData,
+    CustomAgentReference,
+)
+from .types.repository import (
+    Repository,
+    RepositoryMetric,
+)
+from .types.user import (
+    User,
+)
+from .types.references import (
+    AgentSessionReference,
+    AgentTaskReference,
+    RepositoryReference,
+    UserReference,
+    AgentReference,
+    PullRequestIDReference,
+    PullRequestReference,
+    BranchReference,
+)
+from .types.agent_session_log import (
+    AgentSessionLogEntry,
+    AgentSessionLogEntryData,
+)
+from .cast import cast_record
+
+
+class DatasetVersionError(ValueError):
+    pass
+
+
+def assert_version(version: str) -> None:
+    version = version.removeprefix("v")
+    if version != __version__:
+        raise DatasetVersionError(
+            f"Dataset version {version} does not match schema {__version__}. "
+            f"Install risenlab-agentlogs {version} or snapshot revision v{__version__}."
+        )
+
+
+def assert_dataset_version(dataset_path: str | Path) -> None:
+    assert_version(Path(dataset_path).joinpath("VERSION").read_text().strip())
+
+
+__all__ = [
+    "AgentSession",
+    "AgentSessionUsage",
+    "AgentSessionEvent",
+
+    "AgentSessionLogEntry",
+    "AgentSessionLogEntryData",
+
+    "AgentArtifactReference",
+    "PullRequestReference",
+    "BranchReference",
+    "AgentTask",
+    "AgentTaskData",
+    "CustomAgentReference",
+    "PullRequestIDReference",
+    "PullRequestReference",
+    "BranchReference",
+    
+    "Repository",
+    "RepositoryMetric",
+
+    "User",
+
+    "AgentSessionReference",
+    "AgentTaskReference",
+    "RepositoryReference",
+    "UserReference",
+    "AgentReference",
+
+    "cast_record",
+    "DatasetVersionError",
+    "assert_dataset_version",
+    "assert_version",
+    "__version__",
+]

risenlab_agentlogs-0.2/src/agentlogs/schema/cast.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any, Mapping, TypeVar, cast
+
+from .types.agent_session import AgentSession
+from .types.agent_session_log import AgentSessionLogEntry
+from .types.agent_task import AgentTask
+from .types.repository import Repository
+from .types.user import User
+
+T = TypeVar("T", bound=Mapping[str, Any])
+
+TABLE_TYPES = frozenset(
+    {
+        Repository,
+        AgentTask,
+        AgentSession,
+        AgentSessionLogEntry,
+        User,
+    }
+)
+
+def cast_record(cls: type[T], row: Mapping[str, Any]) -> T:
+    if cls not in TABLE_TYPES:
+        raise TypeError("cast_record only supports Repository, AgentTask, AgentSession, AgentSessionLogEntry, and User")
+
+    record = cast(dict[str, Any], row)
+
+    if cls is Repository:
+        for key in ("created_at", "pushed_at", "updated_at", "last_commit_at"):
+            value = record.get(key)
+            if isinstance(value, dt.datetime) and value.tzinfo is None:
+                record[key] = value.replace(tzinfo=dt.timezone.utc)
+
+        languages = record.get("languages")
+        if isinstance(languages, list):
+            if not languages:
+                record["languages"] = {}
+            elif isinstance(languages[0], dict):
+                record["languages"] = {entry["key"]: entry["value"] for entry in languages}
+            else:
+                record["languages"] = dict(languages)
+
+    elif cls is AgentTask:
+        data = record.get("data")
+        if isinstance(data, dict):
+            for key in ("created_at", "updated_at", "archived_at"):
+                value = data.get(key)
+                if isinstance(value, dt.datetime) and value.tzinfo is None:
+                    data[key] = value.replace(tzinfo=dt.timezone.utc)
+
+    elif cls is AgentSession:
+        for key in ("created_at", "updated_at", "completed_at"):
+            value = record.get(key)
+            if isinstance(value, dt.datetime) and value.tzinfo is None:
+                record[key] = value.replace(tzinfo=dt.timezone.utc)
+
+    elif cls is AgentSessionLogEntry:
+        data = record.get("data")
+        if isinstance(data, dict):
+            created = data.get("created")
+            if isinstance(created, dt.datetime) and created.tzinfo is None:
+                data["created"] = created.replace(tzinfo=dt.timezone.utc)
+
+    return cast(T, record)

risenlab_agentlogs-0.2/src/agentlogs/schema/types/agent_session.py

@@ -0,0 +1,50 @@
+import datetime as dt
+from typing import Annotated, TypedDict
+
+from .annotation import GitHubField, Relation
+from .references import (
+    AgentTaskReference,
+    BranchReference,
+    PullRequestReference,
+    UserReference,
+)
+
+class AgentSessionUsage(TypedDict):
+    type: Annotated[str, GitHubField("type")]
+    amount: Annotated[float | None, GitHubField("amount")]
+    credits: Annotated[float | None, GitHubField("credits")]
+
+class AgentSessionEvent(TypedDict):
+    type: Annotated[str | None, GitHubField("event_type")]
+    url: Annotated[str | None, GitHubField("event_url")]
+    ids: Annotated[list[str] | None, GitHubField("event_identifiers")]
+    content: Annotated[str | None, GitHubField("event_content")]
+
+class AgentSession(TypedDict):
+    id: Annotated[str, GitHubField("id")]
+
+    task: Annotated[AgentTaskReference, Relation()]
+    log_found: bool
+
+    user: Annotated[
+        UserReference,
+        GitHubField("user", leaves={"id": "id", "login": "login"}),
+    ]
+
+    name: Annotated[str, GitHubField("name")]
+    model: Annotated[str | None, GitHubField("model")]
+    prompt: Annotated[str | None, GitHubField("prompt")]
+    state: Annotated[str, GitHubField("state")]
+    usage: Annotated[AgentSessionUsage | None, GitHubField("usage")]
+    premium_requests: Annotated[float, GitHubField("premium_requests")]
+    error: Annotated[str | None, GitHubField("error.message")]
+    remote_steerable: Annotated[bool | None, GitHubField("remote_steerable")]
+    workflow_run_id: Annotated[int | None, GitHubField("workflow_run_id")]
+
+    event: AgentSessionEvent
+    pull_request: PullRequestReference | None
+    branch: BranchReference | None
+
+    created_at: Annotated[dt.datetime, GitHubField("created_at")]
+    updated_at: Annotated[dt.datetime, GitHubField("updated_at")]
+    completed_at: Annotated[dt.datetime | None, GitHubField("completed_at")]

risenlab_agentlogs-0.2/src/agentlogs/schema/types/agent_session_log.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Annotated, TypedDict
+
+from .annotation import GitHubField, Note, Relation
+from .references import AgentSessionReference
+
+class AgentSessionLogEntry(TypedDict):
+    session: Annotated[AgentSessionReference, Relation()]
+    entry_index: int
+
+    parsed: bool
+    raw: Annotated[
+        str | None,
+        Note("Not set when `parsed` is true"),
+    ]
+    data: Annotated[
+        AgentSessionLogEntryData | None,
+        GitHubField(""),
+        Note("Not set when `parsed` is false. Refer to `raw` instead"),
+    ]
+
+class AgentSessionLogEntryData(TypedDict):
+    id: Annotated[str | None, GitHubField("id")]
+    agentId: Annotated[str | None, GitHubField("agentId")]
+    arguments: ToolArguments | None
+    callId: Annotated[str | None, GitHubField("callId")]
+    choices: list[Choice] | None
+    content: list[ContentPart] | None
+    copilotBillingMetadata: CopilotBillingMetadata | None
+    copilot_info_messages: Annotated[list[CopilotInfoMessage] | None, GitHubField("copilot_info_messages")]
+    copilot_model_warning_message: Annotated[str | None, GitHubField("copilot_model_warning_message")]
+    copilot_usage: CopilotUsage | None
+    copilot_warning_messages: Annotated[list[CopilotWarningMessage] | None, GitHubField("copilot_warning_messages")]
+    created: Annotated[dt.datetime | None, GitHubField("created")]
+    data: EventData | None
+    ephemeral: Annotated[bool | None, GitHubField("ephemeral")]
+    error: ErrorInfo | None
+    kind: Annotated[str | None, GitHubField("kind")]
+    model: Annotated[str | None, GitHubField("model")]
+    modelCall_error: Annotated[str | None, GitHubField("modelCall.error")]
+    modelCallDurationMs: Annotated[int | None, GitHubField("modelCallDurationMs")]
+    object: Annotated[str | None, GitHubField("object")]
+    output: Annotated[str | None, GitHubField("output")]
+    parentId: Annotated[str | None, GitHubField("parentId")]
+    performedBy: Annotated[str | None, GitHubField("performedBy")]
+    prompt_filter_results: list[PromptFilterResult] | None
+    role: Annotated[str | None, GitHubField("role")]
+    source: Annotated[str | None, GitHubField("source")]
+    system_fingerprint: Annotated[str | None, GitHubField("system_fingerprint")]
+    timestamp: Annotated[str | None, GitHubField("timestamp")]
+    toolCallId: Annotated[str | None, GitHubField("toolCallId")]
+    toolName: Annotated[str | None, GitHubField("toolName")]
+    tool_call_id: Annotated[str | None, GitHubField("tool_call_id")]
+    truncateResult: TruncateResult | None
+    turn: Annotated[int | None, GitHubField("turn")]
+    type: Annotated[str | None, GitHubField("type")]
+    usage: Usage | None
+
+class ContentFilterCategory(TypedDict):
+    filtered: bool
+    severity: str
+
+class ContentFilterResults(TypedDict):
+    hate: ContentFilterCategory | None
+    self_harm: ContentFilterCategory | None
+    sexual: ContentFilterCategory | None
+    violence: ContentFilterCategory | None
+
+class PromptFilterResult(TypedDict):
+    prompt_index: int
+    content_filter_results: ContentFilterResults
+
+class IPCitation(TypedDict):
+    citation_type: str | None
+    ip_type: str
+    license: str
+    snippet: str
+    url: str
+
+class IPCitationEntry(TypedDict):
+    citations: IPCitation
+    end_offset: int
+    id: int
+    start_offset: int | None
+
+class CopilotAnnotations(TypedDict):
+    IPCodeCitations: list[IPCitationEntry] | None
+    raw: str | None
+
+class DeltaToolCall(TypedDict):
+    function_name: str | None
+    function_arguments: str | None
+    custom_name: str | None
+    custom_input: str | None
+    id: str | None
+    index: int | None
+    type: str | None
+
+class MessageToolCall(TypedDict):
+    function_name: str | None
+    function_arguments: str | None
+    id: str | None
+    type: str | None
+
+class Delta(TypedDict):
+    content: str | None
+    copilot_annotations: CopilotAnnotations | None
+    encrypted_content: str | None
+    padding: str | None
+    phase: str | None
+    reasoning_opaque: str | None
+    reasoning_text: str | None
+    role: str | None
+    tool_calls: list[DeltaToolCall] | None
+
+class Message(TypedDict):
+    content: str | None
+    role: str | None
+    tool_calls: list[MessageToolCall] | None
+
+class Choice(TypedDict):
+    content_filter_results: ContentFilterResults | None
+    delta: Delta
+    finish_reason: str | None
+    index: int | None
+    message: Message | None
+
+
+class ToolArguments(TypedDict):
+    canOfferSessionApproval: bool | None
+    command: str | None
+    description: str | None
+    diff: str | None
+    filePath: str | None
+    kind: str | None
+    toolName: str | None
+
+class ContentPart(TypedDict):
+    type: str
+    text: str | None
+    image_url: str | None
+
+class CopilotBillingMetadata(TypedDict):
+    billable: bool
+
+class CopilotInfoMessage(TypedDict):
+    code: Annotated[str, GitHubField("code")]
+    message: Annotated[str, GitHubField("message")]
+
+class CopilotWarningMessage(TypedDict):
+    code: Annotated[str, GitHubField("code")]
+    message: Annotated[str, GitHubField("message")]
+
+class TokenDetail(TypedDict):
+    batch_size: int
+    cost_per_batch: int
+    token_count: int
+    token_type: str
+
+class CopilotUsage(TypedDict):
+    token_details: list[TokenDetail]
+    total_nano_aiu: int
+
+class EventData(TypedDict):
+    actions: list[str] | None
+    alreadyInUse: bool | None
+    approved: bool | None
+    autoApproveEdits: bool | None
+    eventCount: int | None
+    eventsFileSizeBytes: int | None
+    feedback: str | None
+    intent: str | None
+    newMode: str | None
+    planContent: str | None
+    previousMode: str | None
+    reason: str | None
+    reasoningEffort: str | None
+    recommendedAction: str | None
+    remoteSteerable: bool | None
+    requestId: str | None
+    selectedAction: str | None
+    selectedModel: str | None
+    summary: str | None
+    toolCallId: str | None
+    turnId: str | None
+
+class ErrorInfo(TypedDict):
+    code: str
+    message: str
+
+class CompletionTokensDetails(TypedDict):
+    accepted_prediction_tokens: int | None
+    reasoning_tokens: int | None
+    rejected_prediction_tokens: int | None
+
+class PromptTokensDetails(TypedDict):
+    cache_creation_tokens: int | None
+    cached_tokens: int
+    input_tokens: int | None
+    output_tokens: int | None
+
+class UsageCopilotUsage(TypedDict):
+    token_details: list[TokenDetail]
+    total_nano_aiu: int
+
+class Usage(TypedDict):
+    completion_tokens: int
+    completion_tokens_details: CompletionTokensDetails | None
+    copilot_usage: UsageCopilotUsage | None
+    prompt_tokens: int
+    prompt_tokens_details: PromptTokensDetails | None
+    reasoning_tokens: int | None
+    time_in_ms: int | None
+    total_tokens: int
+
+class TruncateResult(TypedDict):
+    messagesRemovedDuringTruncation: int
+    postTruncationMessagesLength: int
+    postTruncationTokensInMessages: int
+    preTruncationMessagesLength: int
+    preTruncationTokensInMessages: int
+    tokenLimit: int
+    tokensRemovedDuringTruncation: int

risenlab_agentlogs-0.2/src/agentlogs/schema/types/agent_task.py

@@ -0,0 +1,60 @@
+import datetime as dt
+from typing import Annotated, TypedDict
+
+from .annotation import GitHubField, Note, Relation
+from .references import (
+    AgentReference,
+    AgentSessionReference,
+    BranchReference,
+    PullRequestIDReference,
+    RepositoryReference,
+    UserReference,
+)
+
+class CustomAgentReference(TypedDict):
+    id: Annotated[str | None, GitHubField("id")]
+    name: Annotated[str | None, GitHubField("name")]
+    is_automation: Annotated[bool | None, GitHubField("is_automation")]
+
+class AgentArtifactReference(TypedDict):
+    type: str
+    pull_request: Annotated[PullRequestIDReference | None, GitHubField("data")]
+    branch: Annotated[BranchReference | None, GitHubField("data")]
+
+class AgentTaskData(TypedDict):
+    name: Annotated[str | None, GitHubField("name")]
+    state: Annotated[str, GitHubField("state")]
+    archived: bool
+    remote_steerable: Annotated[bool, GitHubField("remote_steerable")]
+    sharing_status: Annotated[str, GitHubField("sharing_status")]
+
+    created_at: Annotated[dt.datetime, GitHubField("created_at")]
+    updated_at: Annotated[dt.datetime, GitHubField("updated_at")]
+    archived_at: Annotated[dt.datetime | None, GitHubField("archived_at")]
+
+    custom_agent: Annotated[CustomAgentReference | None, GitHubField("custom_agent")]
+    agent_collaborators: Annotated[list[AgentReference], GitHubField("agent_collaborators[]")]
+    artifacts: Annotated[list[AgentArtifactReference], GitHubField("artifacts[]")]
+
+class AgentTask(TypedDict):
+    id: Annotated[str, GitHubField("id")]
+
+    repository: Annotated[RepositoryReference, Relation()]
+    sessions: Annotated[list[AgentSessionReference], GitHubField("sessions[]")]
+
+    creator: Annotated[
+        UserReference | None,
+        GitHubField("creator", leaves={"id": "id", "login": "login"}),
+        Note("Not set when `found` is false"),
+    ]
+    collaborators: Annotated[
+        list[UserReference] | None,
+        GitHubField("user_collaborators[]", leaves={"id": ""}),
+        Note("Not set when `found` is false"),
+    ]
+
+    found: bool
+    data: Annotated[
+        AgentTaskData | None,
+        Note("Not set when `found` is false"),
+    ]

risenlab_agentlogs-0.2/src/agentlogs/schema/types/annotation.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Description:
+    text: str
+
+@dataclass(frozen=True)
+class Note:
+    text: str
+
+@dataclass(frozen=True)
+class Relation:
+    pass
+
+@dataclass(frozen=True)
+class GitHubField:
+    field: str
+    leaves: dict[str, str] | None = None

risenlab_agentlogs-0.2/src/agentlogs/schema/types/references.py

@@ -0,0 +1,45 @@
+from typing import Annotated, TypedDict
+
+from .annotation import GitHubField
+
+class AgentSessionReference(TypedDict):
+    id: Annotated[str, GitHubField("id")]
+    
+class AgentTaskReference(TypedDict):
+    id: Annotated[str, GitHubField("id")]
+
+class RepositoryReference(TypedDict):
+    full_name: str
+
+class UserReference(TypedDict):
+    id: Annotated[int, GitHubField("id")]
+    login: Annotated[str | None, GitHubField("login")]
+
+class AgentReference(TypedDict):
+    id: Annotated[int, GitHubField("agent_id")]
+
+    # "copilot-developer" | "copilot-developer-cli" | "copilot-pr-reviews" | "vscode-chat"
+    slug: Annotated[str, GitHubField("slug")]
+
+    # Seems to be combination of the following three IDs:
+    #  - Owner ID (internal, not queryable)
+    #  - Repository ID (internal, not queryable)
+    #  - PR GraphQL ID (queryable) / some uuid (not clear what resource)
+    task_id: Annotated[str | None, GitHubField("agent_task_id")]
+
+    # "Integration" | "UserToServerToken" | "OauthApplication" | "IntegrationInstallation" | None
+    type: Annotated[str | None, GitHubField("agent_type")]
+
+class PullRequestIDReference(TypedDict):
+    id: Annotated[int | None, GitHubField("id")]
+    global_id: Annotated[str | None, GitHubField("global_id")]
+
+class PullRequestReference(TypedDict):
+    id: Annotated[int | None, GitHubField("resource_id")]
+    global_id: Annotated[str | None, GitHubField("resource_global_id")]
+    number: Annotated[int | None, GitHubField("resource_number")]
+    state: Annotated[str | None, GitHubField("resource_state")]
+
+class BranchReference(TypedDict):
+    base_ref: Annotated[str, GitHubField("base_ref")]
+    head_ref: Annotated[str | None, GitHubField("head_ref")]

risenlab_agentlogs-0.2/src/agentlogs/schema/types/repository.py

@@ -0,0 +1,55 @@
+import datetime as dt
+from typing import Annotated, TypedDict
+
+from .annotation import GitHubField, Relation
+from .references import AgentTaskReference
+
+class RepositoryMetric(TypedDict):
+    language: str
+    blank_lines: int
+    code_lines: int
+    comment_lines: int
+
+class Repository(TypedDict):
+    full_name: str
+
+    agent_tasks: Annotated[list[AgentTaskReference], GitHubField("tasks[]")]
+
+    archived: Annotated[bool, GitHubField("isArchived")]
+    disabled: Annotated[bool, GitHubField("isDisabled")]
+    locked: Annotated[bool, GitHubField("isLocked")]
+    fork: Annotated[bool, GitHubField("isFork")]
+
+    homepage: Annotated[str | None, GitHubField("homepageUrl")]
+    has_wiki: Annotated[bool, GitHubField("hasWikiEnabled")]
+    license: Annotated[str | None, GitHubField("licenseInfo.name")]
+    main_language: str
+    default_branch: Annotated[str | None, GitHubField("defaultBranchRef.name")]
+    size: Annotated[int, GitHubField("diskUsage")]
+
+    created_at: Annotated[dt.datetime, GitHubField("created_at")]
+    pushed_at: Annotated[dt.datetime, GitHubField("pushed_at")]
+    updated_at: Annotated[dt.datetime, GitHubField("updated_at")]
+    last_commit_at: Annotated[dt.datetime | None, GitHubField("defaultBranchRef.target.committedDate")]
+    last_commit_SHA: Annotated[str | None, GitHubField("defaultBranchRef.target.oid")]
+
+    forks_count: Annotated[int, GitHubField("forkCount")]
+    stargazers_count: Annotated[int, GitHubField("stargazers.totalCount")]
+    watchers_count: Annotated[int | None, GitHubField("watchers.totalCount")]
+    commits_count: Annotated[int | None, GitHubField("defaultBranchRef.target.history.totalCount")]
+    branches_count: Annotated[int | None, GitHubField("refs.totalCount")]
+    releases_count: Annotated[int | None, GitHubField("releases.totalCount")]
+    contributors_count: int | None
+    total_issues_count: Annotated[int | None, GitHubField("issues.totalCount")]
+    open_issues_count: Annotated[int | None, GitHubField("issues(states: OPEN).totalCount")]
+    total_pull_requests_count: Annotated[int | None, GitHubField("pullRequests.totalCount")]
+    open_pull_requests_count: Annotated[int | None, GitHubField("pullRequests(states: OPEN).totalCount")]
+
+    labels: Annotated[list[str], GitHubField("labels.nodes[].name")]
+    topics: Annotated[list[str], GitHubField("repositoryTopics.nodes[].topic.name")]
+    languages: Annotated[dict[str, int], GitHubField("languages")]
+
+    blank_lines: int | None
+    code_lines: int | None
+    comment_lines: int | None
+    metrics: list[RepositoryMetric]

risenlab_agentlogs-0.2/src/agentlogs/schema/types/user.py

@@ -0,0 +1,28 @@
+from typing import Annotated, TypedDict
+
+from .annotation import Note, Relation
+from .references import AgentSessionReference, AgentTaskReference
+
+class User(TypedDict):
+    """
+    A GitHub user or organization
+    """
+
+    id: int
+    found: bool
+    found_using: Annotated[
+        str | None,
+        Note("`'id' | 'login'`. Not set when `found` is false"),
+    ]
+    login: Annotated[
+        str | None,
+        Note("Not set when `found` is false"),
+    ]
+
+    created_tasks: Annotated[list[AgentTaskReference], Relation()]
+    collaborated_tasks: Annotated[
+        list[AgentTaskReference],
+        Relation(),
+        Note("Taken from GitHub's API and may not be complete. Use together with created_tasks and sessions."),
+    ]
+    sessions: Annotated[list[AgentSessionReference], Relation()]