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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.7.1
+Version: 2.8.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.8.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.8.0"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.7.1 → openrunner_sdk-2.8.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.8.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)
 
 
 # ---------------------------------------------------------------------------
@@ -480,21 +509,33 @@ def sync_session_to_openrunner(
     # Create run
     source = parsed["source"]
     timestamp = parsed.get("ended_at", "")[:16].replace("T", " ")
-    run_name = f"{source}/{timestamp}"
+    project_hint = parsed.get("project_hint", "")
+
+    # Build display name: include worktree/project context
+    if project_hint:
+        # Shorten: /home/ubuntu/openrun → openrun
+        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}"
+
+    # Group sessions by source project (worktree)
+    group_name = f"{source}:{project_hint}" if project_hint else f"{source}:default"
 
     run_data = {
         "project": project,
         "display_name": run_name,
+        "group_name": group_name,
         "config": {
             "source": source,
             "session_file": parsed.get("session_file", ""),
-            "project_hint": parsed.get("project_hint", ""),
+            "project_hint": 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}"],
+        "tags": [f"source:{source}", "ai-session", f"visibility:{visibility}", f"worktree:{group_name}"],
         "notes": _format_session_notes(parsed),
         "state": "finished",
     }
@@ -544,30 +585,45 @@ def sync_session_to_openrunner(
 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 +736,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.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.7.1"
+version = "2.8.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"]