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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.5.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.5.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.5.0"
+__version__ = "2.7.0"
 
 logger = logging.getLogger("openrunner")
 

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

@@ -2362,3 +2362,164 @@ def _builtin_suggest(
             result[name] = spec
 
     return result if result else None
+
+
+# ---------------------------------------------------------------------------
+# session commands — AI session capture
+# ---------------------------------------------------------------------------
+
+
+@main.group()
+def session() -> None:
+    """Capture and log AI coding sessions (Claude Code, ChatGPT, Codex, Qwen)."""
+    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: from config)")
+@click.option("--dry-run", is_flag=True, help="Show what would be synced without uploading")
+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).
+
+    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
+        click.echo(f"Found {len(sessions)} session(s):")
+        for s in sessions:
+            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}")
+        if dry_run:
+            return
+
+    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:
+            click.echo(f"  -> run {run_id}")
+    else:
+        click.echo("No new sessions to sync.")
+
+
+@session.command("watch")
+@click.option("--interval", "-i", default=60, help="Check interval in seconds (default: 60)")
+@click.option("--project", "-p", default=None, help="Target project")
+def session_watch(interval: int, project: str | None) -> None:
+    """Watch for new sessions and sync them continuously (daemon mode)."""
+    from openrunner.session import watch
+    click.echo(f"Watching for AI sessions (every {interval}s). Ctrl+C to stop.")
+    try:
+        watch(interval=interval, project=project)
+    except KeyboardInterrupt:
+        click.echo("\nStopped.")
+
+
+@session.command("list")
+@click.option("--hours", "-h", default=24.0, help="Look back N hours")
+def session_list(hours: float) -> None:
+    """List discovered AI sessions."""
+    from openrunner.session import discover_all_sessions, _load_sync_state
+
+    sessions = discover_all_sessions(hours)
+    state = _load_sync_state()
+
+    if not sessions:
+        click.echo("No sessions found.")
+        return
+
+    click.echo(f"{'SOURCE':<14} {'TIME':<18} {'SIZE':<10} {'STATUS'}")
+    click.echo("-" * 60)
+    for s in sessions:
+        from openrunner.session import _session_hash
+        ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(s["mtime"]))
+        size = f"{s['size'] / 1024:.0f} KB"
+        h = _session_hash(s["path"])
+        synced_info = state.get("synced", {}).get(h)
+        status = f"synced ({synced_info['run_id']})" if synced_info else "new"
+        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:
+    """Install/uninstall Claude Code auto-capture hook."""
+    if action == "install":
+        from openrunner.session import install_claude_hook
+        path = install_claude_hook()
+        click.echo(f"Claude Code hook installed.")
+        click.echo(f"  Config: {path}")
+        click.echo("  Sessions will be auto-logged on exit.")
+    else:
+        from pathlib import Path
+        hooks_file = Path.home() / ".claude" / "hooks.json"
+        if hooks_file.exists():
+            import json as json_mod
+            hooks = json_mod.loads(hooks_file.read_text())
+            stop_hooks = hooks.get("hooks", {}).get("Stop", [])
+            hooks["hooks"]["Stop"] = [h for h in stop_hooks if "openrunner" not in str(h)]
+            hooks_file.write_text(json_mod.dumps(hooks, indent=2))
+            click.echo("Claude Code hook removed.")
+        else:
+            click.echo("No hooks.json found.")

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