openrunner-sdk 2.6.0__tar.gz → 2.7.0__tar.gz

{openrunner_sdk-2.6.0 → openrunner_sdk-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.6.0
+Version: 2.7.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

{openrunner_sdk-2.6.0 → openrunner_sdk-2.7.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.6.0"
+__version__ = "2.7.0"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.6.0 → openrunner_sdk-2.7.0}/openrunner/cli.py

@@ -2375,16 +2375,47 @@ def session() -> None:
     pass
 
 
+@session.command("setup")
+def session_setup() -> None:
+    """Interactive setup: configure API key and target project for session sync."""
+    from openrunner.session import interactive_setup
+    config = interactive_setup()
+    if config:
+        click.echo("Setup complete.")
+    else:
+        click.echo("Setup cancelled.")
+
+
 @session.command("sync")
+@click.argument("directory", required=False, type=click.Path(exists=True))
 @click.option("--hours", "-h", default=24.0, help="Look back N hours (default: 24)")
-@click.option("--project", "-p", default=None, help="Target project (default: research-sessions)")
+@click.option("--project", "-p", default=None, help="Target project (default: from config)")
 @click.option("--dry-run", is_flag=True, help="Show what would be synced without uploading")
-def session_sync(hours: float, project: str | None, dry_run: bool) -> None:
-    """Sync recent AI sessions to OpenRunner."""
-    from openrunner.session import discover_all_sessions, sync_all
+def session_sync(directory: str | None, hours: float, project: str | None, dry_run: bool) -> None:
+    """Sync AI sessions to OpenRunner.
+
+    If DIRECTORY is given, scan that path for .jsonl/.json session files.
+    Otherwise, scan default locations (~/.claude, ~/.codex, ~/.qwen-code).
 
-    if dry_run:
+    On first run, prompts for API key and project selection.
+    """
+    from pathlib import Path
+    from openrunner.session import discover_all_sessions, discover_in_directory, sync_all, get_session_config, interactive_setup
+
+    # Check if configured — run setup if not
+    config = get_session_config()
+    if not config.get("api_key"):
+        click.echo("No API key configured. Running first-time setup...")
+        config = interactive_setup()
+        if not config:
+            return
+
+    if directory:
+        sessions = discover_in_directory(Path(directory), since_hours=hours)
+    else:
         sessions = discover_all_sessions(hours)
+
+    if dry_run or not sessions:
         if not sessions:
             click.echo("No sessions found.")
             return
@@ -2393,9 +2424,10 @@ def session_sync(hours: float, project: str | None, dry_run: bool) -> None:
             ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(s["mtime"]))
             size = s["size"] / 1024
             click.echo(f"  [{s['source']}] {ts} ({size:.0f} KB) {s['path'].name}")
-        return
+        if dry_run:
+            return
 
-    synced = sync_all(since_hours=hours, project=project)
+    synced = sync_all(since_hours=hours, project=project, directory=Path(directory) if directory else None)
     if synced:
         click.echo(f"Synced {len(synced)} session(s) to OpenRunner.")
         for run_id in synced:
@@ -2442,6 +2474,33 @@ def session_list(hours: float) -> None:
         click.echo(f"  {s['source']:<12} {ts:<18} {size:<10} {status}")
 
 
+@main.command("install")
+@click.argument("tools", nargs=-1, type=click.Choice(["claude", "codex", "qwen", "opencode"]))
+def install_commands(tools: tuple) -> None:
+    """Install /openrunner slash commands for AI coding tools.
+
+    Without arguments, installs for all tools (Claude Code, Codex, Qwen, OpenCode).
+    Specify tool names to install selectively.
+    """
+    from openrunner.install_commands import install_all
+
+    targets = list(tools) if tools else None
+    results = install_all(targets)
+
+    for tool_name, files in results.items():
+        if files:
+            click.echo(f"  {tool_name}: {len(files)} file(s) installed")
+            for f in files:
+                click.echo(f"    {f}")
+        else:
+            click.echo(f"  {tool_name}: already up to date")
+
+    click.echo("")
+    click.echo("Commands available:")
+    click.echo("  /openrunner:sync-session  — log current session to OpenRunner")
+    click.echo("  /openrunner:log-note      — save a quick research note")
+
+
 @session.command("hook")
 @click.argument("action", type=click.Choice(["install", "uninstall"]))
 def session_hook(action: str) -> None:

openrunner_sdk-2.7.0/openrunner/install_commands.py

@@ -0,0 +1,256 @@
+"""Install OpenRunner slash commands for AI coding tools.
+
+Supports:
+- Claude Code: ~/.claude/commands/openrunner/
+- Codex (OpenAI): ~/.codex/commands/ or AGENTS.md instructions
+- Qwen Code: ~/.qwen-code/commands/
+- OpenCode: ~/.opencode/commands/
+
+Usage:
+    openrunner install          # auto-detect and install all
+    openrunner install claude   # Claude Code only
+    openrunner install codex    # Codex only
+    openrunner install qwen     # Qwen Code only
+    openrunner install opencode # OpenCode only
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Command templates
+# ---------------------------------------------------------------------------
+
+SYNC_SESSION_CMD = """---
+name: {prefix}sync-session
+description: Sync current coding session to OpenRunner as a research log
+---
+
+Sync the current session to OpenRunner. Run:
+
+```bash
+python3 -c "
+import sys, os
+from pathlib import Path
+
+# 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)
+
+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)
+
+latest = max(all_sessions, key=lambda f: f.stat().st_mtime)
+print(f'Syncing: {{latest.name}} ({{latest.stat().st_size // 1024}} KB)')
+
+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)
+
+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)
+if run_id:
+    base = os.environ.get('OPENRUNNER_BASE_URL', 'https://openrun.gladia.io')
+    print(f'Synced -> {{base}}/runs/{{run_id}}')
+else:
+    print('Failed. Run: openrunner login')
+"
+```
+"""
+
+LOG_NOTE_CMD = """---
+name: {prefix}log-note
+description: Log a research note to OpenRunner
+---
+
+Log the user's note text to OpenRunner as a quick research entry. Run:
+
+```bash
+python3 -c "
+import os, sys, json
+from pathlib import Path
+
+for p in [os.path.expanduser('~/.local/lib/python3.12/site-packages'),
+          os.path.expanduser('~/.local/lib/python3.11/site-packages')]:
+    if os.path.isdir(p):
+        sys.path.insert(0, p)
+
+from openrunner.api_client import APIClient
+
+settings_file = Path.home() / '.openrunner' / 'settings.json'
+settings = json.loads(settings_file.read_text()) if settings_file.exists() else {{}}
+api_key = os.environ.get('OPENRUNNER_API_KEY') or settings.get('api_key')
+base_url = os.environ.get('OPENRUNNER_BASE_URL') or settings.get('base_url', 'https://openrun.gladia.io')
+project = os.environ.get('OPENRUNNER_SESSION_PROJECT', 'research-sessions')
+
+note = '''$ARGUMENTS'''
+
+client = APIClient(base_url=base_url, api_key=api_key)
+result = client.create_run({{
+    'project': project,
+    'display_name': f'note: {{note[:50]}}',
+    'notes': note,
+    'tags': ['note', 'quick'],
+    'state': 'finished',
+}})
+if result:
+    print(f'Note logged: run {{result[\"id\"]}}')
+else:
+    print('Failed. Run: openrunner login')
+client.close()
+"
+```
+"""
+
+# ---------------------------------------------------------------------------
+# Installers per tool
+# ---------------------------------------------------------------------------
+
+
+def install_claude_code() -> list[str]:
+    """Install commands in ~/.claude/commands/openrunner/."""
+    cmd_dir = Path.home() / ".claude" / "commands" / "openrunner"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+
+    files = []
+
+    sync_path = cmd_dir / "sync-session.md"
+    sync_path.write_text(SYNC_SESSION_CMD.format(prefix="openrunner:"))
+    files.append(str(sync_path))
+
+    note_path = cmd_dir / "log-note.md"
+    note_path.write_text(LOG_NOTE_CMD.format(prefix="openrunner:"))
+    files.append(str(note_path))
+
+    return files
+
+
+def install_codex() -> list[str]:
+    """Install commands for Codex CLI."""
+    # Codex uses ~/.codex/ with instructions or custom commands
+    cmd_dir = Path.home() / ".codex" / "commands"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+
+    files = []
+
+    sync_path = cmd_dir / "sync-session.md"
+    sync_path.write_text(SYNC_SESSION_CMD.format(prefix="openrunner:"))
+    files.append(str(sync_path))
+
+    note_path = cmd_dir / "log-note.md"
+    note_path.write_text(LOG_NOTE_CMD.format(prefix="openrunner:"))
+    files.append(str(note_path))
+
+    # Also add to AGENTS.md if it exists
+    agents_file = Path.home() / ".codex" / "AGENTS.md"
+    instruction = "\n\n## OpenRunner Integration\nUse `/openrunner:sync-session` to log this session to OpenRunner.\nUse `/openrunner:log-note <text>` to save a research note.\n"
+    if agents_file.exists():
+        content = agents_file.read_text()
+        if "openrunner" not in content.lower():
+            agents_file.write_text(content + instruction)
+            files.append(str(agents_file))
+    else:
+        agents_file.write_text("# Codex Agent Instructions" + instruction)
+        files.append(str(agents_file))
+
+    return files
+
+
+def install_qwen_code() -> list[str]:
+    """Install commands for Qwen Code."""
+    cmd_dir = Path.home() / ".qwen-code" / "commands"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+
+    files = []
+
+    sync_path = cmd_dir / "sync-session.md"
+    sync_path.write_text(SYNC_SESSION_CMD.format(prefix="openrunner:"))
+    files.append(str(sync_path))
+
+    note_path = cmd_dir / "log-note.md"
+    note_path.write_text(LOG_NOTE_CMD.format(prefix="openrunner:"))
+    files.append(str(note_path))
+
+    return files
+
+
+def install_opencode() -> list[str]:
+    """Install commands for OpenCode."""
+    cmd_dir = Path.home() / ".opencode" / "commands"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+
+    files = []
+
+    sync_path = cmd_dir / "sync-session.md"
+    sync_path.write_text(SYNC_SESSION_CMD.format(prefix="openrunner:"))
+    files.append(str(sync_path))
+
+    note_path = cmd_dir / "log-note.md"
+    note_path.write_text(LOG_NOTE_CMD.format(prefix="openrunner:"))
+    files.append(str(note_path))
+
+    return files
+
+
+# ---------------------------------------------------------------------------
+# Main installer
+# ---------------------------------------------------------------------------
+
+TOOLS = {
+    "claude": ("Claude Code", install_claude_code),
+    "codex": ("Codex", install_codex),
+    "qwen": ("Qwen Code", install_qwen_code),
+    "opencode": ("OpenCode", install_opencode),
+}
+
+
+def install_all(targets: list[str] | None = None) -> dict[str, list[str]]:
+    """Install commands for specified tools (or all if None).
+
+    Returns dict of tool_name -> list of installed file paths.
+    """
+    results = {}
+
+    if targets:
+        to_install = [(k, v) for k, v in TOOLS.items() if k in targets]
+    else:
+        # Auto-detect: install for all tools
+        to_install = list(TOOLS.items())
+
+    for key, (name, installer) in to_install:
+        files = installer()
+        results[name] = files
+
+    return results

{openrunner_sdk-2.6.0 → openrunner_sdk-2.7.0}/openrunner/session.py

@@ -72,13 +72,16 @@ def discover_claude_sessions(since_hours: float = 24) -> list[dict]:
 
     cutoff = time.time() - (since_hours * 3600)
     for jsonl in CLAUDE_CODE_DIR.rglob("*.jsonl"):
-        if jsonl.stat().st_mtime < cutoff:
+        stat = jsonl.stat()
+        if stat.st_size < 100 or stat.st_mtime < cutoff:
+            continue
+        if ".meta." in jsonl.name:
             continue
         sessions.append({
             "source": "claude-code",
             "path": jsonl,
-            "mtime": jsonl.stat().st_mtime,
-            "size": jsonl.stat().st_size,
+            "mtime": stat.st_mtime,
+            "size": stat.st_size,
         })
     return sorted(sessions, key=lambda s: s["mtime"], reverse=True)
 
@@ -269,6 +272,147 @@ def parse_generic_session(path: Path, source: str) -> dict[str, Any]:
 # ---------------------------------------------------------------------------
 
 
+def get_session_config(interactive: bool = False) -> dict:
+    """Load or interactively configure session sync settings.
+
+    Config stored in ~/.openrunner/session_config.json:
+    {
+        "api_key": "or_...",
+        "base_url": "https://...",
+        "project": "org/project-name"
+    }
+
+    Per-worktree overrides in .openrunner/session.json (local to cwd).
+    """
+    global_config_file = Path.home() / ".openrunner" / "session_config.json"
+    local_config_file = Path.cwd() / ".openrunner" / "session.json"
+    global_settings_file = Path.home() / ".openrunner" / "settings.json"
+
+    # Load cascade: local > global session config > global settings > env
+    config: dict[str, Any] = {}
+
+    # Global settings (login credentials)
+    if global_settings_file.exists():
+        try:
+            config.update(json.loads(global_settings_file.read_text()))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Global session config
+    if global_config_file.exists():
+        try:
+            config.update(json.loads(global_config_file.read_text()))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Local override
+    if local_config_file.exists():
+        try:
+            config.update(json.loads(local_config_file.read_text()))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    # Env vars take precedence
+    if os.environ.get("OPENRUNNER_API_KEY"):
+        config["api_key"] = os.environ["OPENRUNNER_API_KEY"]
+    if os.environ.get("OPENRUNNER_BASE_URL"):
+        config["base_url"] = os.environ["OPENRUNNER_BASE_URL"]
+    if os.environ.get("OPENRUNNER_SESSION_PROJECT"):
+        config["project"] = os.environ["OPENRUNNER_SESSION_PROJECT"]
+
+    return config
+
+
+def save_session_config(config: dict, local: bool = False) -> None:
+    """Save session config globally or locally."""
+    if local:
+        config_file = Path.cwd() / ".openrunner" / "session.json"
+    else:
+        config_file = Path.home() / ".openrunner" / "session_config.json"
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    config_file.write_text(json.dumps(config, indent=2))
+
+
+def interactive_setup() -> dict:
+    """Interactive first-run setup: prompt for API key and project selection.
+
+    Returns config dict with api_key, base_url, project.
+    """
+    from openrunner.api_client import APIClient
+
+    config = get_session_config()
+
+    # Step 1: API key
+    api_key = config.get("api_key")
+    base_url = config.get("base_url", "https://openrun.gladia.io")
+
+    if not api_key:
+        print("OpenRunner session sync — first-time setup")
+        print("=" * 50)
+        api_key = input("API Key (from OpenRunner settings): ").strip()
+        if not api_key:
+            print("No API key provided. Aborting.")
+            return {}
+        base_url_input = input(f"Server URL [{base_url}]: ").strip()
+        if base_url_input:
+            base_url = base_url_input
+
+    # Step 2: Verify key works
+    client = APIClient(base_url=base_url, api_key=api_key)
+    try:
+        resp = client._request("get", "/auth/me")
+        if resp.status_code != 200:
+            print(f"API key invalid (HTTP {resp.status_code}). Check your key.")
+            client.close()
+            return {}
+        user_info = resp.json()
+        print(f"Authenticated as: {user_info.get('display_name', user_info.get('email', '?'))}")
+    except Exception as e:
+        print(f"Connection failed: {e}")
+        client.close()
+        return {}
+
+    # Step 3: Select project
+    project = config.get("project")
+    if not project:
+        print("\nSelect project for session logs:")
+        projects = client.list_projects()
+        if not projects:
+            print("No projects found. Create one in OpenRunner first.")
+            client.close()
+            return {}
+
+        for i, p in enumerate(projects, 1):
+            org = p.get("org_name", p.get("organization", {}).get("name", "?"))
+            name = p.get("name", "?")
+            print(f"  [{i}] {org}/{name}")
+
+        choice = input(f"\nProject number [1-{len(projects)}]: ").strip()
+        try:
+            idx = int(choice) - 1
+            p = projects[idx]
+            org = p.get("org_name", p.get("organization", {}).get("name", ""))
+            project = f"{org}/{p['name']}" if org else p["name"]
+        except (ValueError, IndexError):
+            print("Invalid selection.")
+            client.close()
+            return {}
+
+    client.close()
+
+    config_out = {
+        "api_key": api_key,
+        "base_url": base_url,
+        "project": project,
+    }
+
+    # Save
+    save_session_config(config_out)
+    print(f"\nConfig saved. Sessions will sync to: {project}")
+    print(f"Config file: ~/.openrunner/session_config.json")
+    return config_out
+
+
 def sync_session_to_openrunner(
     parsed: dict[str, Any],
     project: str | None = None,
@@ -281,25 +425,18 @@ def sync_session_to_openrunner(
     """
     from openrunner.api_client import APIClient
 
-    # Load settings from ~/.openrunner/settings.json
-    if not api_key or not base_url:
-        settings_file = Path.home() / ".openrunner" / "settings.json"
-        settings = {}
-        if settings_file.exists():
-            try:
-                settings = json.loads(settings_file.read_text())
-            except (json.JSONDecodeError, OSError):
-                pass
-        api_key = api_key or os.environ.get("OPENRUNNER_API_KEY") or settings.get("api_key")
-        base_url = base_url or os.environ.get("OPENRUNNER_BASE_URL") or settings.get("base_url")
+    # Load config (cascade: args > env > session_config > settings)
+    config = get_session_config()
+    api_key = api_key or config.get("api_key")
+    base_url = base_url or config.get("base_url")
 
     if not api_key or not base_url:
         logger.warning("No API key or base URL configured. Run 'openrunner login' first.")
         return None
 
-    # Determine project
+    # Determine project from config cascade
     if not project:
-        project = os.environ.get("OPENRUNNER_SESSION_PROJECT", "research-sessions")
+        project = config.get("project") or "research-sessions"
 
     client = APIClient(base_url=base_url, api_key=api_key)
 
@@ -397,8 +534,49 @@ def _format_session_notes(parsed: dict) -> str:
 # ---------------------------------------------------------------------------
 
 
+def discover_in_directory(directory: Path, since_hours: float = 24) -> list[dict]:
+    """Discover session files in a given directory (recursive).
+
+    Detects source by path heuristics:
+    - .claude in path → claude-code
+    - .codex in path → codex
+    - .qwen in path → qwen
+    - Otherwise → generic
+    """
+    sessions = []
+    cutoff = time.time() - (since_hours * 3600)
+
+    for pattern in ("**/*.jsonl", "**/*.json"):
+        for f in directory.glob(pattern):
+            stat = f.stat()
+            # Skip empty files, meta files, and old files
+            if stat.st_size < 100 or stat.st_mtime < cutoff:
+                continue
+            if ".meta." in f.name:
+                continue
+            # Detect source from path
+            path_str = str(f).lower()
+            if ".claude" in path_str:
+                source = "claude-code"
+            elif ".codex" in path_str:
+                source = "codex"
+            elif ".qwen" in path_str:
+                source = "qwen"
+            elif "openai" in path_str or "chatgpt" in path_str:
+                source = "chatgpt"
+            else:
+                source = "claude-code"  # default — most common format
+            sessions.append({
+                "source": source,
+                "path": f,
+                "mtime": stat.st_mtime,
+                "size": stat.st_size,
+            })
+    return sorted(sessions, key=lambda s: s["mtime"], reverse=True)
+
+
 def discover_all_sessions(since_hours: float = 24) -> list[dict]:
-    """Discover sessions from all sources."""
+    """Discover sessions from all default sources."""
     all_sessions = []
     all_sessions.extend(discover_claude_sessions(since_hours))
     all_sessions.extend(discover_codex_sessions(since_hours))
@@ -411,10 +589,11 @@ def sync_all(
     since_hours: float = 24,
     project: str | None = None,
     dry_run: bool = False,
+    directory: Path | None = None,
 ) -> list[str]:
     """Discover and sync all new sessions. Returns list of synced run IDs."""
     state = _load_sync_state()
-    sessions = discover_all_sessions(since_hours)
+    sessions = discover_in_directory(directory, since_hours) if directory else discover_all_sessions(since_hours)
     synced_ids = []
 
     for session_info in sessions:

{openrunner_sdk-2.6.0 → openrunner_sdk-2.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.6.0"
+version = "2.7.0"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}