openrunner-sdk 2.7.1__tar.gz → 2.9.0__tar.gz

{openrunner_sdk-2.7.1 → openrunner_sdk-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.7.1
+Version: 2.9.0
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner
@@ -33,6 +33,7 @@ Requires-Dist: catboost>=1.2; extra == 'catboost'
 Provides-Extra: dev
 Requires-Dist: numpy>=1.24; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Provides-Extra: diffusers
 Requires-Dist: diffusers>=0.25; extra == 'diffusers'

{openrunner_sdk-2.7.1 → openrunner_sdk-2.9.0}/openrunner/__init__.py

@@ -120,7 +120,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.7.1"
+__version__ = "2.9.0"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.7.1 → openrunner_sdk-2.9.0}/openrunner/install_commands.py

@@ -26,68 +26,90 @@ from pathlib import Path
 SYNC_SESSION_CMD = """---
 name: {prefix}sync-session
 description: Sync current coding session to OpenRunner as a research log
+argument-hint: "[org/project]"
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
 ---
 
-Sync the current session to OpenRunner. Run:
+Sync the current Claude Code session to OpenRunner.
+
+## Process
+
+### Step 1: Check configuration
+
+Run this to check if session config exists:
 
 ```bash
 python3 -c "
-import sys, os
+import json
 from pathlib import Path
+config_file = Path.home() / '.openrunner' / 'session_config.json'
+if config_file.exists():
+    config = json.loads(config_file.read_text())
+    if config.get('api_key') and config.get('project'):
+        print('CONFIGURED')
+        print(f'project={{config[\"project\"]}}')
+    else:
+        print('INCOMPLETE')
+else:
+    print('NOT_CONFIGURED')
+"
+```
 
-# Ensure openrunner is importable
-for p in [os.path.expanduser('~/.local/lib/python3.12/site-packages'),
-          os.path.expanduser('~/.local/lib/python3.11/site-packages'),
-          os.path.expanduser('~/.local/lib/python3.10/site-packages')]:
-    if os.path.isdir(p):
-        sys.path.insert(0, p)
+### Step 2a: If NOT_CONFIGURED or INCOMPLETE
 
-from openrunner.session import discover_in_directory, parse_claude_session, parse_generic_session, sync_session_to_openrunner
-
-# Find session dir for current tool
-session_dirs = [
-    Path.home() / '.claude' / 'projects',
-    Path.home() / '.codex' / 'sessions',
-    Path.home() / '.qwen-code' / 'sessions',
-    Path.home() / '.opencode' / 'sessions',
-]
-
-# Find most recent session file across all sources
-all_sessions = []
-for d in session_dirs:
-    if d.exists():
-        for f in d.rglob('*.jsonl'):
-            if f.stat().st_size > 100 and '.meta.' not in f.name:
-                all_sessions.append(f)
-        for f in d.rglob('*.json'):
-            if f.stat().st_size > 100 and '.meta.' not in f.name:
-                all_sessions.append(f)
-
-if not all_sessions:
-    print('No sessions found.')
-    sys.exit(1)
+Ask the user for their OpenRunner API key and base URL. Then list projects and ask them to pick one. Save to ~/.openrunner/session_config.json.
 
-latest = max(all_sessions, key=lambda f: f.stat().st_mtime)
-print(f'Syncing: {{latest.name}} ({{latest.stat().st_size // 1024}} KB)')
+### Step 2b: If CONFIGURED (or after setup)
 
-if latest.suffix == '.jsonl' and '.claude' in str(latest):
-    parsed = parse_claude_session(latest)
-else:
-    source = 'codex' if '.codex' in str(latest) else 'qwen' if '.qwen' in str(latest) else 'opencode'
-    parsed = parse_generic_session(latest, source)
+Sync the current session. Use $ARGUMENTS as project override if provided:
+
+```bash
+python3 -c "
+import sys, os
+from pathlib import Path
+for p in [os.path.expanduser(f'~/.local/lib/python3.{{v}}/site-packages') for v in (12,11,10)]:
+    if os.path.isdir(p): sys.path.insert(0, p)
+from openrunner.session import parse_claude_session, sync_session_to_openrunner, get_session_config
+
+cwd = Path.cwd()
+cwd_key = '-' + str(cwd).replace('/', '-').lstrip('-')
+project_dir = Path.home() / '.claude' / 'projects' / cwd_key
+if not project_dir.exists():
+    for d in (Path.home() / '.claude' / 'projects').iterdir():
+        if d.is_dir() and cwd_key in d.name:
+            project_dir = d
+            break
+
+sessions = sorted(
+    [f for f in project_dir.rglob('*.jsonl') if f.stat().st_size > 100 and '.meta.' not in f.name],
+    key=lambda f: f.stat().st_mtime, reverse=True,
+) if project_dir.exists() else []
+
+if not sessions:
+    print('No session files found.')
+    sys.exit(1)
 
+latest = sessions[0]
+print(f'Syncing: {{latest.name}} ({{latest.stat().st_size // 1024}} KB)')
+parsed = parse_claude_session(latest)
 print(f'  Messages: {{parsed[\"message_count\"]}} ({{parsed[\"user_message_count\"]}} user)')
 print(f'  Tokens: {{parsed.get(\"total_tokens\", 0):,}}')
 
-project = os.environ.get('OPENRUNNER_SESSION_PROJECT', 'research-sessions')
-run_id = sync_session_to_openrunner(parsed, project=project)
+project_override = '$ARGUMENTS'.strip() or None
+run_id = sync_session_to_openrunner(parsed, project=project_override)
 if run_id:
-    base = os.environ.get('OPENRUNNER_BASE_URL', 'https://openrun.gladia.io')
+    config = get_session_config()
+    base = config.get('base_url', 'https://openrun.gladia.io')
     print(f'Synced -> {{base}}/runs/{{run_id}}')
 else:
-    print('Failed. Run: openrunner login')
+    print('Sync failed. Run: openrunner session setup')
 "
 ```
+
+### Step 3: Report the run URL and stats to the user.
 """
 
 LOG_NOTE_CMD = """---

{openrunner_sdk-2.7.1 → openrunner_sdk-2.9.0}/openrunner/session.py

@@ -137,8 +137,15 @@ def parse_claude_session(path: Path) -> dict[str, Any]:
             total_tokens += usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
 
     # Extract project context from path
-    # ~/.claude/projects/-home-user-myproject/session.jsonl
-    project_hint = path.parent.name.replace("-", "/").lstrip("/")
+    # ~/.claude/projects/-home-user-myproject/session-id.jsonl
+    # or ~/.claude/projects/-home-user-myproject/subagents/agent-xxx.jsonl
+    parts = path.parts
+    # Find the project dir (child of "projects")
+    project_hint = ""
+    for i, p in enumerate(parts):
+        if p == "projects" and i + 1 < len(parts):
+            project_hint = parts[i + 1].replace("-", "/").lstrip("/")
+            break
 
     # Build summary
     user_messages = [m for m in messages if m["role"] == "user"]
@@ -170,19 +177,41 @@ def _estimate_duration(path: Path) -> float:
 
 
 def _summarize_session(messages: list[dict]) -> str:
-    """Generate a text summary from messages."""
-    user_msgs = [m["content"] for m in messages if m["role"] == "user"]
+    """Generate a structured summary from messages.
+
+    Extracts: topic, key actions, outcomes.
+    """
+    user_msgs = [m["content"] for m in messages if m["role"] == "user" and m.get("content")]
+    assistant_msgs = [m["content"] for m in messages if m["role"] == "assistant" and m.get("content")]
+
     if not user_msgs:
         return "Empty session"
 
-    # Use first and last user messages as summary
     parts = []
-    if user_msgs:
-        parts.append(f"Started: {user_msgs[0][:100]}")
+
+    # Topic from first message
+    parts.append(f"**Topic:** {user_msgs[0][:150]}")
+
+    # Key user requests (sample up to 5 distinct short ones)
+    if len(user_msgs) > 2:
+        key_requests = []
+        for msg in user_msgs[1:]:
+            # Skip very short messages (confirmations) and very long ones (pastes)
+            if 10 < len(msg) < 200:
+                key_requests.append(msg.strip()[:80])
+            if len(key_requests) >= 5:
+                break
+        if key_requests:
+            parts.append("**Key requests:** " + " → ".join(key_requests))
+
+    # Last request
     if len(user_msgs) > 1:
-        parts.append(f"Last: {user_msgs[-1][:100]}")
-    parts.append(f"({len(user_msgs)} user messages)")
-    return " | ".join(parts)
+        parts.append(f"**Last:** {user_msgs[-1][:100]}")
+
+    # Stats
+    parts.append(f"**Stats:** {len(user_msgs)} requests, {len(assistant_msgs)} responses")
+
+    return "\n".join(parts)
 
 
 # ---------------------------------------------------------------------------
@@ -477,97 +506,146 @@ def sync_session_to_openrunner(
 
     client = APIClient(base_url=base_url, api_key=api_key)
 
-    # Create run
+    # Resolve project_id from "org/project" format
+    project_id = None
+    try:
+        projects = client.list_projects()
+        for p in projects:
+            org_name = p.get("org_name", "")
+            proj_name = p.get("name", "")
+            full_name = f"{org_name}/{proj_name}" if org_name else proj_name
+            if full_name == project or proj_name == project:
+                project_id = p.get("id")
+                break
+    except Exception:
+        pass
+
+    if not project_id:
+        # Fallback: try creating as a run (backward compat with older servers)
+        logger.warning(f"Could not resolve project '{project}', falling back to run creation")
+        return _sync_as_run_fallback(client, parsed, project, visibility)
+
+    # Build AI session data
     source = parsed["source"]
+    project_hint = parsed.get("project_hint", "")
     timestamp = parsed.get("ended_at", "")[:16].replace("T", " ")
-    run_name = f"{source}/{timestamp}"
 
-    run_data = {
-        "project": project,
-        "display_name": run_name,
-        "config": {
-            "source": source,
-            "session_file": parsed.get("session_file", ""),
-            "project_hint": parsed.get("project_hint", ""),
-            "message_count": parsed.get("message_count", 0),
-            "user_message_count": parsed.get("user_message_count", 0),
-            "tools_used": parsed.get("tools_used", []),
-            "total_tokens": parsed.get("total_tokens", 0),
-        },
-        "tags": [f"source:{source}", "ai-session", f"visibility:{visibility}"],
+    if project_hint:
+        short_hint = project_hint.rsplit("/", 1)[-1] if "/" in project_hint else project_hint
+        title = f"{source}/{short_hint}/{timestamp}"
+    else:
+        title = f"{source}/{timestamp}"
+
+    group_key = f"{source}:{project_hint}" if project_hint else f"{source}:default"
+
+    session_data = {
+        "title": title,
+        "source": source,
+        "worktree": project_hint,
+        "group_key": group_key,
+        "summary": parsed.get("summary"),
         "notes": _format_session_notes(parsed),
-        "state": "finished",
+        "first_message": parsed.get("first_message"),
+        "messages": parsed.get("messages"),
+        "message_count": parsed.get("message_count", 0),
+        "user_message_count": parsed.get("user_message_count", 0),
+        "total_tokens": parsed.get("total_tokens", 0),
+        "tools_used": parsed.get("tools_used", []),
+        "files_touched": parsed.get("files_touched", []),
+        "visibility": visibility,
+        "tags": [f"source:{source}", f"worktree:{group_key}"],
+        "redacted": bool(parsed.get("_redaction")),
+        "redaction_mode": parsed.get("_redaction", {}).get("mode") if parsed.get("_redaction") else None,
+        "session_file": parsed.get("session_file"),
+        "started_at": parsed.get("started_at"),
+        "ended_at": parsed.get("ended_at"),
     }
 
-    # Add redaction metadata if applied
-    if parsed.get("_redaction"):
-        run_data["config"]["redacted"] = True
-        run_data["config"]["redaction_mode"] = parsed["_redaction"]["mode"]
-        run_data["config"]["entities_redacted"] = parsed["_redaction"]["entities_redacted"]
-
-    result = client.create_run(run_data)
-    if not result:
-        logger.warning("Failed to create session run")
+    # POST to /projects/{project_id}/ai-sessions
+    try:
+        resp = client._request("post", f"/projects/{project_id}/ai-sessions", json=session_data)
+        if resp.status_code in (200, 201):
+            result = resp.json()
+            client.close()
+            return result.get("id")
+        else:
+            # Server doesn't have AI sessions endpoint yet — fall back to run
+            logger.info("AI sessions endpoint not available, falling back to run")
+            return _sync_as_run_fallback(client, parsed, project, visibility)
+    except Exception as e:
+        logger.warning(f"AI session sync failed: {e}")
         client.close()
         return None
 
-    run_id = result.get("id")
 
-    # Log metrics
-    metrics = []
-    if parsed.get("total_tokens"):
-        metrics.append({"key": "tokens", "value": parsed["total_tokens"], "step": 1})
-    if parsed.get("message_count"):
-        metrics.append({"key": "messages", "value": parsed["message_count"], "step": 1})
-    if parsed.get("user_message_count"):
-        metrics.append({"key": "user_messages", "value": parsed["user_message_count"], "step": 1})
-    if parsed.get("files_touched"):
-        metrics.append({"key": "files_touched", "value": len(parsed["files_touched"]), "step": 1})
-
-    if metrics and run_id:
-        client.post_metrics(run_id, metrics)
-
-    # Log files touched as summary
-    if parsed.get("files_touched") and run_id:
-        client.update_run(run_id, {
-            "summary": {
-                "files_touched": len(parsed["files_touched"]),
-                "tools_used": len(parsed.get("tools_used", [])),
-                "tokens": parsed.get("total_tokens", 0),
-            }
-        })
+def _sync_as_run_fallback(client, parsed: dict, project: str, visibility: str) -> str | None:
+    """Fallback: create a run if AI sessions endpoint not available."""
+    source = parsed["source"]
+    timestamp = parsed.get("ended_at", "")[:16].replace("T", " ")
+    project_hint = parsed.get("project_hint", "")
+
+    if project_hint:
+        short_hint = project_hint.rsplit("/", 1)[-1] if "/" in project_hint else project_hint
+        run_name = f"{source}/{short_hint}/{timestamp}"
+    else:
+        run_name = f"{source}/{timestamp}"
+
+    run_data = {
+        "project": project,
+        "display_name": run_name,
+        "group_name": f"{source}:{project_hint}" if project_hint else f"{source}:default",
+        "tags": [f"source:{source}", "ai-session"],
+        "notes": _format_session_notes(parsed),
+        "state": "finished",
+    }
 
+    result = client.create_run(run_data)
     client.close()
-    return run_id
+    return result.get("id") if result else None
 
 
 def _format_session_notes(parsed: dict) -> str:
     """Format parsed session into readable notes."""
     lines = []
-    lines.append(f"# {parsed['source'].title()} Session")
+    source = parsed.get("source", "unknown").replace("-", " ").title()
+    lines.append(f"# {source} Session")
     lines.append(f"**Time:** {parsed.get('started_at', '?')[:16]} → {parsed.get('ended_at', '?')[:16]}")
+    if parsed.get("project_hint"):
+        lines.append(f"**Project:** `{parsed['project_hint']}`")
+    lines.append(f"**Tokens:** {parsed.get('total_tokens', 0):,}")
     lines.append("")
 
     if parsed.get("first_message"):
-        lines.append(f"## First Request")
+        lines.append("## Initial Request")
         lines.append(parsed["first_message"])
         lines.append("")
 
+    if parsed.get("summary"):
+        lines.append("## Summary")
+        lines.append(parsed["summary"])
+        lines.append("")
+
     if parsed.get("tools_used"):
         lines.append(f"## Tools Used ({len(parsed['tools_used'])})")
-        for t in parsed["tools_used"][:20]:
-            lines.append(f"- {t}")
+        lines.append(", ".join(parsed["tools_used"][:20]))
         lines.append("")
 
     if parsed.get("files_touched"):
-        lines.append(f"## Files Touched ({len(parsed['files_touched'])})")
+        lines.append(f"## Files Modified ({len(parsed['files_touched'])})")
         for f in parsed["files_touched"][:30]:
             lines.append(f"- `{f}`")
         lines.append("")
 
-    if parsed.get("summary"):
-        lines.append(f"## Summary")
-        lines.append(parsed["summary"])
+    # Extract key conversation flow (first 10 user messages as bullet points)
+    messages = parsed.get("messages", [])
+    user_msgs = [m["content"] for m in messages if m.get("role") == "user" and m.get("content") and len(m["content"]) > 10]
+    if len(user_msgs) > 2:
+        lines.append("## Conversation Flow")
+        for msg in user_msgs[:15]:
+            lines.append(f"- {msg[:120]}")
+        if len(user_msgs) > 15:
+            lines.append(f"- ... ({len(user_msgs) - 15} more)")
+        lines.append("")
 
     return "\n".join(lines)
 
@@ -680,26 +758,46 @@ def sync_all(
 HOOK_SCRIPT = '''#!/usr/bin/env python3
 """Auto-log Claude Code session to OpenRunner on exit."""
 import sys
+import os
 from pathlib import Path
 
 def main():
-    # Find the most recent session file that was just written
-    from openrunner.session import discover_claude_sessions, parse_claude_session, sync_session_to_openrunner
+    try:
+        from openrunner.session import discover_claude_sessions, parse_claude_session, sync_session_to_openrunner
+
+        # Find the session for the CWD project (not just any recent session)
+        cwd = Path.cwd()
+        cwd_key = "-" + str(cwd).replace("/", "-").lstrip("-")
+        project_dir = Path.home() / ".claude" / "projects" / cwd_key
+
+        if project_dir.exists():
+            # Find most recent .jsonl in this project
+            sessions = sorted(
+                [f for f in project_dir.glob("*.jsonl") if f.stat().st_size > 100 and ".meta." not in f.name],
+                key=lambda f: f.stat().st_mtime,
+                reverse=True,
+            )
+        else:
+            # Fallback: most recent globally
+            sessions_info = discover_claude_sessions(since_hours=0.1)
+            sessions = [s["path"] for s in sessions_info]
 
-    sessions = discover_claude_sessions(since_hours=0.1)  # last 6 minutes
-    if not sessions:
-        return
+        if not sessions:
+            return
 
-    latest = sessions[0]
-    parsed = parse_claude_session(latest["path"])
+        latest = sessions[0]
+        parsed = parse_claude_session(latest)
 
-    # Only sync if meaningful (>2 user messages)
-    if parsed.get("user_message_count", 0) < 2:
-        return
+        # Only sync if meaningful (>2 user messages)
+        if parsed.get("user_message_count", 0) < 2:
+            return
 
-    run_id = sync_session_to_openrunner(parsed)
-    if run_id:
-        print(f"openrunner: Session logged as run {run_id}", file=sys.stderr)
+        run_id = sync_session_to_openrunner(parsed)
+        if run_id:
+            print(f"openrunner: Session logged as run {run_id}", file=sys.stderr)
+    except Exception as e:
+        # Never crash Claude Code on hook failure
+        print(f"openrunner hook: {e}", file=sys.stderr)
 
 if __name__ == "__main__":
     main()

{openrunner_sdk-2.7.1 → openrunner_sdk-2.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.7.1"
+version = "2.9.0"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}
@@ -58,7 +58,7 @@ whisper = ["openai-whisper>=20231117"]
 tts = ["matplotlib>=3.7", "numpy>=1.24"]
 voice-agent = []
 forced-alignment = ["matplotlib>=3.7", "numpy>=1.24"]
-dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "numpy>=1.24"]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23", "pytest-cov>=5.0", "numpy>=1.24"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["openrunner"]