aicodinggym-cli 0.1.0__py3-none-any.whl

aicodinggym/__init__.py

@@ -0,0 +1,3 @@
+"""AI Coding Gym CLI."""
+
+__version__ = "0.1.0"

aicodinggym/api.py

@@ -0,0 +1,132 @@
+"""HTTP API client for the AI Coding Gym backend at aicodinggym.com."""
+
+import requests
+
+API_BASE = "https://aicodinggym.com/api"
+TIMEOUT = 30
+
+
+class APIError(Exception):
+    """Raised when an API call fails."""
+    pass
+
+
+def _post(endpoint: str, payload: dict, timeout: int = TIMEOUT) -> dict:
+    """Make a POST request to the API and return parsed JSON."""
+    url = f"{API_BASE}/{endpoint}"
+    try:
+        resp = requests.post(url, json=payload, timeout=timeout)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.ConnectionError:
+        raise APIError(
+            f"Cannot connect to {API_BASE}.\n"
+            "Check your internet connection and try again."
+        )
+    except requests.Timeout:
+        raise APIError(f"Request to {url} timed out after {timeout}s.")
+    except requests.HTTPError as e:
+        body = ""
+        try:
+            body = e.response.json().get("detail", e.response.text)
+        except Exception:
+            body = e.response.text
+        raise APIError(f"API error (HTTP {e.response.status_code}): {body}")
+    except requests.RequestException as e:
+        raise APIError(f"Request failed: {e}")
+
+
+def _get(endpoint: str, timeout: int = TIMEOUT, stream: bool = False) -> requests.Response:
+    """Make a GET request to the API and return the raw response."""
+    url = f"{API_BASE}/{endpoint}"
+    try:
+        resp = requests.get(url, timeout=timeout, stream=stream)
+        resp.raise_for_status()
+        return resp
+    except requests.ConnectionError:
+        raise APIError(
+            f"Cannot connect to {API_BASE}.\n"
+            "Check your internet connection and try again."
+        )
+    except requests.Timeout:
+        raise APIError(f"Request to {url} timed out after {timeout}s.")
+    except requests.HTTPError as e:
+        body = ""
+        try:
+            body = e.response.json().get("detail", e.response.text)
+        except Exception:
+            body = e.response.text
+        raise APIError(f"API error (HTTP {e.response.status_code}): {body}")
+    except requests.RequestException as e:
+        raise APIError(f"Request failed: {e}")
+
+
+def configure(user_id: str, public_key: str) -> dict:
+    """Register public key with server. Returns {'repo_name': ...}."""
+    return _post("configure", {"user_id": user_id, "public_key": public_key})
+
+
+def fetch_problem(user_id: str, problem_id: str) -> dict:
+    """Fetch problem info. Returns {'branch_name': ..., 'repo_url': ..., 'message': ...}."""
+    return _post("fetch-problem", {"user_id": user_id, "problem_id": problem_id})
+
+
+def submit_notification(problem_id: str, user_id: str, commit_hash: str,
+                        branch: str, commit_message: str, timestamp: str) -> dict:
+    """Notify backend of a submission."""
+    return _post("submissions", {
+        "problem_id": problem_id,
+        "user_id": user_id,
+        "commit_hash": commit_hash,
+        "branch": branch,
+        "commit_message": commit_message,
+        "timestamp": timestamp,
+    })
+
+
+def mlebench_download_info(user_id: str, competition_id: str, dest_path: str) -> None:
+    """Download dataset for an MLE-bench competition directly to dest_path."""
+    resp = _get(f"competitions/{competition_id}/download", stream=True)
+    with open(dest_path, "wb") as f:
+        for chunk in resp.iter_content(chunk_size=8192):
+            f.write(chunk)
+
+
+def mlebench_download_file(url: str, dest_path: str, timeout: int = 300) -> None:
+    """Download a file from the given URL to dest_path with progress."""
+    try:
+        resp = requests.get(url, stream=True, timeout=timeout)
+        resp.raise_for_status()
+        with open(dest_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                f.write(chunk)
+    except requests.RequestException as e:
+        raise APIError(f"Download failed: {e}")
+
+
+def mlebench_submit_csv(user_id: str, competition_id: str, csv_path: str) -> dict:
+    """Upload a prediction CSV for an MLE-bench competition."""
+    try:
+        with open(csv_path, "rb") as f:
+            resp = requests.post(
+                f"{API_BASE}/competitions/{competition_id}/submit",
+                data={"user_id": user_id, "competition_id": competition_id},
+                files={"file": (f.name, f, "text/csv")},
+                timeout=60,
+            )
+            resp.raise_for_status()
+            return resp.json()
+    except requests.ConnectionError:
+        raise APIError(
+            f"Cannot connect to {API_BASE}.\n"
+            "Check your internet connection and try again."
+        )
+    except requests.HTTPError as e:
+        body = ""
+        try:
+            body = e.response.json().get("detail", e.response.text)
+        except Exception:
+            body = e.response.text
+        raise APIError(f"API error (HTTP {e.response.status_code}): {body}")
+    except requests.RequestException as e:
+        raise APIError(f"Request failed: {e}")

aicodinggym/cli.py

@@ -0,0 +1,641 @@
+"""AI Coding Gym CLI - main entry point.
+
+A command-line tool for the AI Coding Gym platform (https://aicodinggym.com).
+Supports SWE-bench and MLE-bench challenges.
+
+SETUP (required before any other command):
+    aicodinggym configure --user-id YOUR_USER_ID
+
+SWE-BENCH WORKFLOW:
+    aicodinggym swe fetch django__django-10097
+    # ... edit code to fix the issue ...
+    aicodinggym swe submit django__django-10097
+
+MLE-BENCH WORKFLOW:
+    aicodinggym mle download spaceship-titanic
+    # ... train model, generate predictions ...
+    aicodinggym mle submit spaceship-titanic -F submission.csv
+"""
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import click
+
+from . import __version__
+from .api import (
+    APIError,
+    configure as api_configure,
+    fetch_problem as api_fetch_problem,
+    mlebench_download_file,
+    mlebench_download_info,
+    mlebench_submit_csv,
+    submit_notification,
+)
+from .config import (
+    load_config,
+    load_credentials,
+    save_config,
+    save_credentials,
+)
+from .git_ops import (
+    add_commit_push,
+    clone_repo,
+    generate_ssh_key_pair,
+    reset_to_setup_commit,
+)
+
+
+def _error(msg: str) -> None:
+    """Print an error message to stderr and exit."""
+    click.echo(f"Error: {msg}", err=True)
+    sys.exit(1)
+
+
+def _warn(msg: str) -> None:
+    """Print a warning message to stderr."""
+    click.echo(f"Warning: {msg}", err=True)
+
+
+def _resolve_user_id(config: dict, user_id: str | None) -> str:
+    """Resolve user_id from argument or config, with helpful error."""
+    if user_id:
+        return user_id
+    uid = config.get("user_id")
+    if not uid:
+        _error(
+            "User ID is not configured.\n\n"
+            "Run 'aicodinggym configure --user-id YOUR_USER_ID' first.\n"
+            "This generates an SSH key and registers it with aicodinggym.com."
+        )
+    return uid
+
+
+def _resolve_workspace(config: dict, workspace_dir: str | None) -> Path:
+    """Resolve workspace directory from argument or config."""
+    if workspace_dir:
+        return Path(workspace_dir).resolve()
+    configured = config.get("workspace_dir")
+    if configured:
+        return Path(configured).resolve()
+    return Path.cwd().resolve()
+
+
+def _resolve_key_path(config: dict, creds: dict | None = None) -> Path:
+    """Resolve SSH private key path from credentials or config."""
+    path_str = None
+    if creds:
+        path_str = creds.get("private_key_path")
+    if not path_str:
+        path_str = config.get("private_key_path")
+    if not path_str:
+        _error(
+            "SSH key path not found.\n\n"
+            "Run 'aicodinggym configure --user-id YOUR_USER_ID' to generate a key.\n"
+            "If you previously configured, your config may be corrupted.\n"
+            "Config location: ~/.aicodinggym/config.json"
+        )
+    key_path = Path(path_str)
+    if not key_path.exists():
+        _error(
+            f"SSH key file not found at: {key_path}\n\n"
+            "Run 'aicodinggym configure --user-id YOUR_USER_ID' to regenerate.\n"
+            "This will create a new SSH key pair and register it with the server."
+        )
+    return key_path
+
+
+# ── Top-level group ──────────────────────────────────────────────────────────
+
+
+@click.group(
+    epilog=(
+        "\b\n"
+        "SETUP (run once before using other commands):\n"
+        "  aicodinggym configure --user-id YOUR_USER_ID\n"
+        "  (user_id is required — get yours at https://aicodinggym.com)\n\n"
+        "\b\n"
+        "EXAMPLES:\n"
+        "  aicodinggym swe fetch django__django-10097\n"
+        "  aicodinggym swe submit django__django-10097 --message 'Fix auth bug'\n"
+        "  aicodinggym mle download spaceship-titanic\n"
+        "  aicodinggym mle submit spaceship-titanic -F predictions.csv\n\n"
+        "\b\n"
+        "WEBSITE:\n"
+        "  https://aicodinggym.com\n"
+    ),
+)
+@click.version_option(__version__, prog_name="aicodinggym")
+def main():
+    """AI Coding Gym CLI.
+
+    A command-line interface for the AI Coding Gym platform
+    (https://aicodinggym.com). Provides tools to fetch coding problems,
+    download datasets, and submit solutions.
+
+    Designed for use by both humans and LLM/AI agents.
+
+    \b
+    QUICK START:
+      1. Configure:  aicodinggym configure --user-id YOUR_USER_ID
+      2. Fetch:      aicodinggym swe fetch PROBLEM_ID
+      3. Solve:      (edit code in the cloned repository)
+      4. Submit:     aicodinggym swe submit PROBLEM_ID
+    """
+    pass
+
+
+# ── configure ────────────────────────────────────────────────────────────────
+
+
+@main.command()
+@click.option(
+    "--user-id", required=True,
+    help="Your AI Coding Gym user ID. Get one at https://aicodinggym.com.",
+)
+@click.option(
+    "--workspace-dir", default=None, type=click.Path(),
+    help="Default workspace directory for cloning repositories. "
+         "Defaults to the current working directory.",
+)
+def configure(user_id: str, workspace_dir: str | None):
+    """Configure credentials and register SSH key with aicodinggym.com.
+
+    Generates an SSH key pair locally (stored in ~/.aicodinggym/),
+    sends the public key to the server, and saves your configuration.
+
+    \b
+    This command must be run once before using any other commands.
+    If you've already configured, running again will reuse your existing key.
+
+    \b
+    WHAT IT DOES:
+      1. Generates SSH key pair in ~/.aicodinggym/
+      2. Registers your public key with the AI Coding Gym server
+      3. Receives your assigned repository name
+      4. Saves all settings to ~/.aicodinggym/config.json
+
+    \b
+    EXAMPLE:
+      aicodinggym configure --user-id alice123
+      aicodinggym configure --user-id alice123 --workspace-dir ~/gym-workspace
+    """
+    try:
+        click.echo(f"Generating SSH key for user '{user_id}'...")
+        private_key_path, public_key = generate_ssh_key_pair(user_id)
+
+        click.echo("Registering public key with aicodinggym.com...")
+        try:
+            data = api_configure(user_id, public_key)
+            repo_name = data.get("repo_name")
+            if not repo_name:
+                _error("Server did not return a repository name. Please try again or contact support.")
+        except APIError as e:
+            if "409" in str(e):
+                click.echo("Key already registered, reusing existing configuration.")
+                existing = load_config()
+                repo_name = existing.get("repo_name", f"submission-{user_id}")
+            else:
+                raise
+
+        resolved_workspace = str(Path(workspace_dir).resolve()) if workspace_dir else str(Path.cwd().resolve())
+
+        config = {
+            "user_id": user_id,
+            "repo_name": repo_name,
+            "private_key_path": str(private_key_path),
+            "workspace_dir": resolved_workspace,
+        }
+        save_config(config)
+
+        click.echo(
+            f"\nConfiguration saved successfully!\n"
+            f"\n"
+            f"  User ID:     {user_id}\n"
+            f"  Repository:  {repo_name}\n"
+            f"  Workspace:   {resolved_workspace}\n"
+            f"  SSH Key:     {private_key_path}\n"
+            f"  Config:      ~/.aicodinggym/config.json\n"
+            f"\n"
+            f"You can now use 'aicodinggym swe' and 'aicodinggym mle' commands."
+        )
+    except APIError as e:
+        _error(str(e))
+    except Exception as e:
+        _error(f"Configuration failed: {e}")
+
+
+# ── swe group ────────────────────────────────────────────────────────────────
+
+
+@main.group()
+def swe():
+    """SWE-bench coding challenges - fetch, solve, and submit bug fixes.
+
+    \b
+    PREREQUISITE:
+      Run 'aicodinggym configure --user-id YOUR_USER_ID' before using these commands.
+
+    \b
+    WORKFLOW:
+      1. aicodinggym swe fetch PROBLEM_ID     # Clone the problem repo
+      2. (edit code to fix the issue)          # Work on your solution
+      3. aicodinggym swe submit PROBLEM_ID     # Submit your fix
+      4. aicodinggym swe reset PROBLEM_ID      # (optional) Start over
+
+    \b
+    PROBLEM IDS:
+      Problem IDs follow the format: <project>__<repo>-<number>
+      Examples: django__django-10097, sympy__sympy-13043, scikit-learn__scikit-learn-11578
+    """
+    pass
+
+
+@swe.command("fetch")
+@click.argument("problem_id")
+@click.option("--user-id", default=None, help="Override configured user ID.")
+@click.option(
+    "--workspace-dir", default=None, type=click.Path(),
+    help="Directory to clone into. Overrides configured workspace.",
+)
+def swe_fetch(problem_id: str, user_id: str | None, workspace_dir: str | None):
+    """Fetch a SWE-bench problem and clone its repository locally.
+
+    Contacts the AI Coding Gym server to set up the problem branch,
+    then clones the repository into your workspace directory.
+
+    \b
+    PREREQUISITE:
+      You must run 'aicodinggym configure --user-id YOUR_USER_ID' first.
+      If you haven't configured yet, this command will fail with instructions.
+
+    \b
+    ARGUMENTS:
+      PROBLEM_ID  The unique problem identifier (e.g., 'django__django-10097').
+                  Get problem IDs from https://aicodinggym.com.
+
+    \b
+    WHAT IT DOES:
+      1. Requests the problem branch from the server
+      2. Clones the repository (shallow clone for efficiency)
+      3. Sets up your local workspace at <workspace>/<problem_id>/
+
+    \b
+    EXAMPLE:
+      aicodinggym swe fetch django__django-10097
+      aicodinggym swe fetch django__django-10097 --workspace-dir ~/projects
+    """
+    config = load_config()
+    uid = _resolve_user_id(config, user_id)
+    workspace = _resolve_workspace(config, workspace_dir)
+    key_path = _resolve_key_path(config)
+
+    try:
+        click.echo(f"Fetching problem '{problem_id}' from server...")
+        data = api_fetch_problem(uid, problem_id)
+    except APIError as e:
+        _error(str(e))
+
+    branch = data.get("branch_name", problem_id)
+    repo_url = data.get("repo_url")
+    server_msg = data.get("message", "")
+
+    if not repo_url:
+        _error("Server did not return a repository URL. The problem may not exist.")
+
+    # Save credentials for later submit
+    credentials = load_credentials()
+    credentials[problem_id] = {
+        "repo_url": repo_url,
+        "branch": branch,
+        "user_id": uid,
+        "private_key_path": str(key_path),
+        "workspace_dir": str(workspace),
+        "benchmark": "swe",
+    }
+    save_credentials(credentials)
+
+    workspace.mkdir(parents=True, exist_ok=True)
+
+    click.echo(f"Cloning branch '{branch}' into {workspace / problem_id}...")
+    success, msg = clone_repo(repo_url, branch, problem_id, str(workspace), key_path)
+
+    if not success:
+        _error(msg)
+
+    click.echo(
+        f"\nSuccessfully fetched problem: {problem_id}\n"
+        f"\n"
+        f"  {msg}\n"
+    )
+    if server_msg:
+        click.echo(f"  Server: {server_msg}\n")
+    click.echo("You can now start working on the solution!")
+
+
+@swe.command("submit")
+@click.argument("problem_id")
+@click.option("--user-id", default=None, help="Override configured user ID.")
+@click.option(
+    "--message", "-m", default=None,
+    help="Commit message. Auto-generated if not provided.",
+)
+@click.option(
+    "--force", is_flag=True, default=False,
+    help="Force push (--force-with-lease). Use with caution.",
+)
+@click.option(
+    "--workspace-dir", default=None, type=click.Path(),
+    help="Workspace directory. Overrides configured/cached value.",
+)
+def swe_submit(problem_id: str, user_id: str | None, message: str | None,
+               force: bool, workspace_dir: str | None):
+    """Submit your SWE-bench solution by committing and pushing changes.
+
+    Stages all changes, commits them, pushes to the remote, and notifies
+    the AI Coding Gym server that your submission is ready for evaluation.
+
+    \b
+    PREREQUISITE:
+      You must run 'aicodinggym swe fetch PROBLEM_ID' first.
+      The fetch command sets up the repository and caches credentials
+      needed for submission.
+
+    \b
+    ARGUMENTS:
+      PROBLEM_ID  The problem identifier you fetched earlier.
+
+    \b
+    WHAT IT DOES:
+      1. Stages all changed files (git add)
+      2. Commits with your message (or auto-generated one)
+      3. Pushes to the remote branch
+      4. Notifies the backend for evaluation
+
+    \b
+    EXAMPLE:
+      aicodinggym swe submit django__django-10097
+      aicodinggym swe submit django__django-10097 -m "Fix auth validation bug"
+      aicodinggym swe submit django__django-10097 --force
+    """
+    config = load_config()
+    uid = _resolve_user_id(config, user_id)
+
+    credentials = load_credentials()
+    if problem_id not in credentials:
+        _error(
+            f"No credentials found for '{problem_id}'.\n\n"
+            f"You must fetch the problem first:\n"
+            f"  aicodinggym swe fetch {problem_id}\n\n"
+            f"This clones the repository and saves the credentials needed for submission."
+        )
+
+    creds = credentials[problem_id]
+
+    if creds.get("user_id") and creds["user_id"] != uid:
+        _error(
+            f"User ID mismatch. Problem was fetched by '{creds['user_id']}', not '{uid}'.\n"
+            f"Either use --user-id {creds['user_id']} or re-fetch the problem."
+        )
+
+    workspace = _resolve_workspace(config, workspace_dir or creds.get("workspace_dir"))
+    problem_dir = workspace / problem_id
+
+    if not problem_dir.exists():
+        _error(
+            f"Problem directory not found at: {problem_dir}\n\n"
+            f"You must fetch the problem first:\n"
+            f"  aicodinggym swe fetch {problem_id}\n\n"
+            f"Or specify the correct workspace with --workspace-dir."
+        )
+
+    key_path = _resolve_key_path(config, creds)
+    branch = creds["branch"]
+    commit_msg = message or f"Solution submission for {problem_id} at {datetime.now().isoformat()}"
+
+    click.echo(f"Submitting solution for '{problem_id}'...")
+    success, msg, commit_hash = add_commit_push(str(problem_dir), branch, key_path, commit_msg, force)
+
+    if not success:
+        _error(msg)
+
+    # Notify backend
+    try:
+        submit_notification(
+            problem_id=problem_id,
+            user_id=uid,
+            commit_hash=commit_hash,
+            branch=branch,
+            commit_message=commit_msg,
+            timestamp=datetime.now().isoformat(),
+        )
+    except APIError as e:
+        _warn(f"Changes pushed, but failed to notify backend: {e}")
+
+    click.echo(
+        f"\nSuccessfully submitted solution for {problem_id}\n"
+        f"\n"
+        f"  Commit:  {commit_hash[:8]}\n"
+        f"  Branch:  {branch}\n"
+        f"  Status:  Pushed and backend notified\n"
+        f"\n"
+        f"Your solution has been submitted for evaluation!"
+    )
+
+
+@swe.command("reset")
+@click.argument("problem_id")
+@click.option("--user-id", default=None, help="Override configured user ID.")
+@click.option(
+    "--workspace-dir", default=None, type=click.Path(),
+    help="Workspace directory. Overrides configured/cached value.",
+)
+def swe_reset(problem_id: str, user_id: str | None, workspace_dir: str | None):
+    """Reset a SWE-bench problem to its original state.
+
+    Discards all local changes and resets the repository back to the
+    original setup commit. Use this to start over on a problem.
+
+    \b
+    WARNING: This is destructive. All your local changes will be lost.
+
+    \b
+    PREREQUISITE:
+      You must run 'aicodinggym swe fetch PROBLEM_ID' first.
+
+    \b
+    ARGUMENTS:
+      PROBLEM_ID  The problem identifier to reset.
+
+    \b
+    WHAT IT DOES:
+      1. Finds the original 'Setup SWE-bench instance:' commit
+      2. Runs git reset --hard to that commit
+      3. Removes untracked files (git clean -fd)
+
+    \b
+    EXAMPLE:
+      aicodinggym swe reset django__django-10097
+    """
+    config = load_config()
+    uid = _resolve_user_id(config, user_id)
+
+    credentials = load_credentials()
+    if problem_id not in credentials:
+        _error(
+            f"No credentials found for '{problem_id}'.\n\n"
+            f"You must fetch the problem first:\n"
+            f"  aicodinggym swe fetch {problem_id}"
+        )
+
+    creds = credentials[problem_id]
+
+    if creds.get("user_id") and creds["user_id"] != uid:
+        _error(f"User ID mismatch. Problem was fetched by '{creds['user_id']}', not '{uid}'.")
+
+    workspace = _resolve_workspace(config, workspace_dir or creds.get("workspace_dir"))
+    problem_dir = workspace / problem_id
+
+    if not problem_dir.exists():
+        _error(f"Problem directory not found at: {problem_dir}")
+
+    click.echo(f"Resetting '{problem_id}' to original state...")
+    success, msg = reset_to_setup_commit(str(problem_dir))
+
+    if not success:
+        _error(msg)
+
+    click.echo(f"\n{msg}")
+
+
+# ── mle group ────────────────────────────────────────────────────────────────
+
+
+@main.group()
+def mle():
+    """MLE-bench ML competitions - download data and submit predictions.
+
+    \b
+    PREREQUISITE:
+      Run 'aicodinggym configure --user-id YOUR_USER_ID' before using these commands.
+
+    \b
+    WORKFLOW:
+      1. aicodinggym mle download COMPETITION_ID                        # Download dataset
+      2. (train your model and generate predictions)                    # Work on your solution
+      3. aicodinggym mle submit COMPETITION_ID -F submission.csv     # Submit predictions
+
+    \b
+    COMPETITION IDS:
+      Examples: spaceship-titanic, house-prices, digit-recognizer
+      Browse competitions at https://aicodinggym.com
+    """
+    pass
+
+
+@mle.command("download")
+@click.argument("competition_id")
+@click.option("--user-id", default=None, help="Override configured user ID.")
+@click.option(
+    "--workspace-dir", default=None, type=click.Path(),
+    help="Workspace directory. Defaults to configured workspace.",
+)
+def mle_download(competition_id: str, user_id: str | None, workspace_dir: str | None):
+    """Download dataset files for an MLE-bench competition.
+
+    \b
+    EXAMPLE:
+      aicodinggym mle download spaceship-titanic
+      aicodinggym mle download spaceship-titanic --workspace-dir ~/workspace
+    """
+    config = load_config()
+    uid = _resolve_user_id(config, user_id)
+
+    workspace = _resolve_workspace(config, workspace_dir)
+    dest_dir = workspace / competition_id / "data"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = f"{competition_id}.zip"
+    dest_path = dest_dir / filename
+
+    try:
+        click.echo(f"Downloading dataset for '{competition_id}'...")
+        mlebench_download_info(uid, competition_id, str(dest_path))
+    except APIError as e:
+        _error(str(e))
+
+    click.echo(
+        f"\nDataset downloaded to: {dest_path}\n"
+        f"\nNext step: train your model and submit predictions with:\n"
+        f"  aicodinggym mle submit {competition_id} -F your_predictions.csv"
+    )
+
+
+@mle.command("submit")
+@click.argument("competition_id")
+@click.option(
+    "-F", "csv_path", required=True, type=click.Path(exists=True),
+    help="Path to your prediction CSV file (required).",
+)
+@click.option("--user-id", default=None, help="Override configured user ID.")
+@click.option(
+    "--message", "-m", default=None,
+    help="Description of your submission (optional).",
+)
+def mle_submit(competition_id: str, csv_path: str, user_id: str | None,
+               message: str | None):
+    """Submit a prediction CSV for an MLE-bench competition.
+
+    Uploads your prediction CSV directly to the AI Coding Gym server
+    for scoring.
+
+    \b
+    PREREQUISITE:
+      You must run 'aicodinggym configure --user-id YOUR_USER_ID' first.
+
+    \b
+    ARGUMENTS:
+      COMPETITION_ID  The competition identifier (e.g., 'spaceship-titanic').
+
+    \b
+    OPTIONS:
+      -F FILE  Path to your prediction CSV file. This is REQUIRED.
+               The file must exist and be a valid CSV matching the
+               competition's expected format (see sample_submission.csv).
+
+    \b
+    WHAT IT DOES:
+      1. Validates that the CSV file exists
+      2. Uploads the CSV to the AI Coding Gym server
+      3. Server scores your predictions and returns results
+
+    \b
+    EXAMPLE:
+      aicodinggym mle submit spaceship-titanic -F predictions.csv
+      aicodinggym mle submit spaceship-titanic -F ./output/pred.csv -m "XGBoost v2"
+    """
+    config = load_config()
+    uid = _resolve_user_id(config, user_id)
+
+    csv_src = Path(csv_path).resolve()
+
+    click.echo(f"Uploading {csv_src.name} for '{competition_id}'...")
+
+    try:
+        result = mlebench_submit_csv(uid, competition_id, str(csv_src))
+    except APIError as e:
+        _error(str(e))
+
+    score_msg = result.get("message", "Submission received for scoring.")
+    score = result.get("score")
+
+    click.echo(
+        f"\nSuccessfully submitted prediction for {competition_id}\n"
+        f"\n"
+        f"  CSV:     {csv_src.name}\n"
+        f"  Status:  {score_msg}\n"
+    )
+    if score is not None:
+        click.echo(f"  Score:   {score}\n")
+    click.echo("Your prediction has been submitted for scoring!")

aicodinggym/config.py

@@ -0,0 +1,80 @@
+"""Configuration and credentials management for AI Coding Gym CLI.
+
+Stores configuration in ~/.aicodinggym/config.json and per-problem
+credentials in ~/.aicodinggym/credentials.json.
+SSH keys are stored in ~/.aicodinggym/{user_id}_id_rsa.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+CONFIG_DIR = Path.home() / ".aicodinggym"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+CREDENTIALS_PATH = CONFIG_DIR / "credentials.json"
+
+# Fields persisted in config.json
+_CONFIG_FIELDS = ("user_id", "repo_name", "private_key_path", "workspace_dir")
+
+
+def ensure_config_dir() -> Path:
+    """Create the config directory with secure permissions if it doesn't exist."""
+    CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+    return CONFIG_DIR
+
+
+def load_config() -> dict[str, str]:
+    """Load global configuration from ~/.aicodinggym/config.json."""
+    if not CONFIG_PATH.exists():
+        return {}
+    try:
+        data = json.loads(CONFIG_PATH.read_text())
+        if not isinstance(data, dict):
+            return {}
+        return {k: v for k, v in data.items() if k in _CONFIG_FIELDS and isinstance(v, str) and v}
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(config: dict[str, str]) -> None:
+    """Persist global configuration to ~/.aicodinggym/config.json."""
+    ensure_config_dir()
+    data = {k: v for k, v in config.items() if k in _CONFIG_FIELDS}
+    CONFIG_PATH.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def load_credentials() -> dict[str, dict[str, Any]]:
+    """Load per-problem credentials from ~/.aicodinggym/credentials.json."""
+    if not CREDENTIALS_PATH.exists():
+        return {}
+    try:
+        data = json.loads(CREDENTIALS_PATH.read_text())
+        if not isinstance(data, dict):
+            return {}
+        return data
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_credentials(credentials: dict[str, dict[str, Any]]) -> None:
+    """Persist per-problem credentials to ~/.aicodinggym/credentials.json."""
+    ensure_config_dir()
+    CREDENTIALS_PATH.write_text(json.dumps(credentials, indent=2) + "\n")
+
+
+def require_config(config: dict[str, str], field: str, label: str) -> str:
+    """Get a required config field or raise a descriptive error."""
+    value = config.get(field)
+    if not value:
+        raise ConfigError(
+            f"{label} is not configured.\n\n"
+            f"Run 'aicodinggym configure --user-id YOUR_USER_ID' first to set up your credentials.\n"
+            f"This generates an SSH key and registers it with the AI Coding Gym server."
+        )
+    return value
+
+
+class ConfigError(Exception):
+    """Raised when required configuration is missing."""
+    pass

aicodinggym/git_ops.py

@@ -0,0 +1,175 @@
+"""Git and SSH key operations for AI Coding Gym CLI."""
+
+import os
+import shlex
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from .config import ensure_config_dir
+
+
+def generate_ssh_key_pair(user_id: str) -> tuple[Path, str]:
+    """Generate an SSH key pair for the user.
+
+    First checks ~/.mcp-keys/ for existing keys matching the user_id.
+    If found, copies them to ~/.aicodinggym/ and reuses them.
+    Otherwise generates new keys in ~/.aicodinggym/{user_id}_id_rsa.
+    Returns (private_key_path, public_key_content).
+    """
+    key_dir = ensure_config_dir()
+    key_path = key_dir / f"{user_id}_id_rsa"
+
+    if not key_path.exists():
+        # Check ~/.mcp-keys/ for existing keys matching user_id
+        mcp_keys_dir = Path.home() / ".mcp-keys"
+        mcp_private = mcp_keys_dir / f"{user_id}_id_rsa"
+        mcp_public = mcp_keys_dir / f"{user_id}_id_rsa.pub"
+
+        if mcp_private.exists() and mcp_public.exists():
+            shutil.copy2(mcp_private, key_path)
+            shutil.copy2(mcp_public, Path(f"{key_path}.pub"))
+            key_path.chmod(0o600)
+        else:
+            result = subprocess.run(
+                ["ssh-keygen", "-t", "rsa", "-b", "4096", "-f", str(key_path),
+                 "-N", "", "-C", f"aicodinggym-{user_id}"],
+                capture_output=True, text=True,
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to generate SSH key: {result.stderr}")
+
+    pub_key_path = Path(f"{key_path}.pub")
+    public_key = pub_key_path.read_text().strip()
+    return key_path, public_key
+
+
+def run_git_command(cmd: str, cwd: str, key_path: Optional[Path] = None) -> subprocess.CompletedProcess:
+    """Execute a git command with optional SSH key configuration."""
+    env = os.environ.copy()
+    if key_path:
+        env["GIT_SSH_COMMAND"] = f"ssh -i {key_path} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+
+    return subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True, env=env)
+
+
+def clone_repo(repo_url: str, branch: str, dest_name: str,
+               workspace: str, key_path: Path) -> tuple[bool, str]:
+    """Clone a repo branch into workspace/dest_name.
+
+    Returns (success, message).
+    """
+    problem_dir = Path(workspace) / dest_name
+
+    if problem_dir.exists():
+        # Check if already on the correct branch
+        result = run_git_command("git rev-parse --abbrev-ref HEAD", str(problem_dir))
+        if result.returncode == 0 and result.stdout.strip() == branch:
+            pull = run_git_command(f"git pull origin {branch}", str(problem_dir), key_path)
+            if pull.returncode != 0:
+                return False, f"Git pull failed:\n{pull.stderr}"
+            _remove_github_dir(problem_dir)
+            return True, f"Already exists. Updated to latest version.\nRepository: {problem_dir}\nBranch: {branch}"
+        return False, (
+            f"Directory {problem_dir} already exists with different content.\n"
+            "Remove it first or use --workspace-dir to specify a different location."
+        )
+
+    cmd = f"git clone --single-branch --branch {branch} --depth 1 {repo_url} {dest_name}"
+    result = run_git_command(cmd, workspace, key_path)
+
+    if result.returncode != 0:
+        return False, f"Git clone failed:\n{result.stderr}\nMake sure the branch '{branch}' exists in the repository."
+
+    _remove_github_dir(problem_dir)
+    return True, f"Cloned to: {problem_dir}\nBranch: {branch}"
+
+
+def add_commit_push(problem_dir: str, branch: str, key_path: Path,
+                    message: str, force: bool = False) -> tuple[bool, str, str]:
+    """Stage, commit, and push changes.
+
+    Returns (success, message, commit_hash).
+    """
+    pdir = Path(problem_dir)
+
+    # Stage all changes except .github
+    result = run_git_command("git add -A -- . ':(exclude).github'", str(pdir))
+    if result.returncode != 0:
+        return False, f"Git add failed:\n{result.stderr}", ""
+
+    # Check for staged changes
+    status = run_git_command("git diff --cached --name-only", str(pdir))
+    if not status.stdout.strip():
+        return False, "No changes to commit. Your working directory is clean.", ""
+
+    # Commit
+    safe_msg = message.replace('"', '\\"')
+    result = run_git_command(f'git commit -m "{safe_msg}"', str(pdir))
+    if result.returncode != 0:
+        return False, f"Git commit failed:\n{result.stderr}", ""
+
+    # Get commit hash
+    hash_result = run_git_command("git rev-parse HEAD", str(pdir))
+    commit_hash = hash_result.stdout.strip()
+
+    # Push
+    push_flag = "--force-with-lease " if force else ""
+    result = run_git_command(f"git push {push_flag}origin {branch}", str(pdir), key_path)
+    if result.returncode != 0:
+        return False, f"Git push failed:\n{result.stderr}", commit_hash
+
+    return True, "Committed and pushed successfully.", commit_hash
+
+
+def reset_to_setup_commit(problem_dir: str) -> tuple[bool, str]:
+    """Reset repo to the original 'Setup SWE-bench instance:' commit.
+
+    Returns (success, message).
+    """
+    log_result = run_git_command("git log --format=%H:%s --reverse", problem_dir)
+    if log_result.returncode != 0:
+        return False, f"Git log failed:\n{log_result.stderr}"
+
+    setup_prefix = "Setup SWE-bench instance:"
+    setup_commit = None
+    for line in log_result.stdout.splitlines():
+        parts = line.split(":", 1)
+        if len(parts) != 2:
+            continue
+        commit_hash, subject = parts[0].strip(), parts[1].strip()
+        if subject.startswith(setup_prefix):
+            setup_commit = commit_hash
+            break
+
+    if not setup_commit:
+        return False, (
+            f"Could not find the original setup commit.\n"
+            f"Expected a commit message starting with '{setup_prefix}'."
+        )
+
+    reset = run_git_command(f"git reset --hard {setup_commit}", problem_dir)
+    if reset.returncode != 0:
+        return False, f"Git reset failed:\n{reset.stderr}"
+
+    clean = run_git_command("git clean -fd", problem_dir)
+    if clean.returncode != 0:
+        return False, f"Git clean failed:\n{clean.stderr}"
+
+    return True, f"Reset to setup commit {setup_commit[:8]}.\nLocal changes discarded and untracked files removed."
+
+
+def _remove_github_dir(problem_dir: Path) -> None:
+    """Remove .github directory and mark files as skip-worktree."""
+    github_dir = problem_dir / ".github"
+    if not github_dir.exists():
+        return
+
+    list_result = run_git_command("git ls-files .github", str(problem_dir))
+    if list_result.returncode == 0:
+        for rel_path in filter(None, list_result.stdout.splitlines()):
+            quoted = shlex.quote(rel_path)
+            run_git_command(f"git update-index --skip-worktree -- {quoted}", str(problem_dir))
+
+    shutil.rmtree(github_dir, ignore_errors=True)

aicodinggym_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: aicodinggym-cli
+Version: 0.1.0
+Summary: CLI tool for AI Coding Gym platform
+Author-email: AICodingGym Team <datasmithlab@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://aicodinggym.com
+Keywords: cli,coding-gym,swebench,mlebench,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.31.0
+
+# aicodinggym-cli API Design
+
+## Overview
+
+CLI tool for the AI Coding Gym platform (`https://aicodinggym.com`).
+Supports two benchmarks: **SWE-bench** (code bug fixes) and **MLE-bench** (ML competitions).
+
+**Install:** `pip install aicodinggym-cli`
+**Entry point:** `aicodinggym`
+
+---
+
+## Commands
+
+### `aicodinggym configure`
+
+One-time setup. Generates SSH key, registers with server.
+
+```
+aicodinggym configure --user-id USER_ID [--workspace-dir DIR]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `--user-id` | Yes | Your AI Coding Gym user ID |
+| `--workspace-dir` | No | Default workspace directory (default: cwd) |
+
+**Backend API:** `POST /api/configure`
+```json
+// Request
+{"user_id": "alice123", "public_key": "ssh-rsa AAAA..."}
+// Response
+{"repo_name": "alice123-swebench"}
+```
+
+**Local storage:** `~/.aicodinggym/config.json`, `~/.aicodinggym/{user_id}_id_rsa`
+
+---
+
+### `aicodinggym swe` — SWE-bench Commands
+
+#### `aicodinggym swe fetch PROBLEM_ID`
+
+Fetch a problem and clone the repo locally (shallow clone).
+
+```
+aicodinggym swe fetch PROBLEM_ID [--user-id ID] [--workspace-dir DIR]
+```
+
+**Backend API:** `POST /api/fetch-problem`
+```json
+// Request
+{"user_id": "alice123", "problem_id": "django__django-10097"}
+// Response
+{"branch_name": "django__django-10097-alice123", "repo_url": "git@...", "message": "..."}
+```
+
+**Local effect:** Clones `<workspace>/<problem_id>/` via SSH.
+
+---
+
+#### `aicodinggym swe submit PROBLEM_ID`
+
+Commit all changes and push to remote. Notifies backend.
+
+```
+aicodinggym swe submit PROBLEM_ID [--message MSG] [--force] [--user-id ID] [--workspace-dir DIR]
+```
+
+| Option | Description |
+|---|---|
+| `--message, -m` | Commit message (auto-generated if omitted) |
+| `--force` | Force push with `--force-with-lease` |
+
+**Local effect:** `git add -A`, `git commit`, `git push`
+
+**Backend API:** `POST /api/submissions`
+```json
+// Request
+{
+  "problem_id": "django__django-10097",
+  "user_id": "alice123",
+  "commit_hash": "abc123...",
+  "branch": "django__django-10097-alice123",
+  "commit_message": "Fix auth bug",
+  "timestamp": "2026-03-05T10:30:00"
+}
+// Response
+{"status": "success", "message": "Submission received"}
+```
+
+---
+
+#### `aicodinggym swe reset PROBLEM_ID`
+
+Reset repo to original setup commit. Destructive — discards all local changes.
+
+```
+aicodinggym swe reset PROBLEM_ID [--user-id ID] [--workspace-dir DIR]
+```
+
+**Local effect:** `git reset --hard <setup_commit>`, `git clean -fd`
+
+---
+
+### `aicodinggym mle` — MLE-bench Commands
+
+#### `aicodinggym mle download COMPETITION_ID`
+
+Download dataset files (train/test/sample_submission CSVs).
+
+```
+aicodinggym mle download COMPETITION_ID [--user-id ID] [--output-dir DIR]
+```
+
+| Option | Description |
+|---|---|
+| `--output-dir` | Save location (default: `./<competition_id>/data/`) |
+
+**Backend API:** `POST /api/mlebench/download`
+```json
+// Request
+{"user_id": "alice123", "competition_id": "spaceship-titanic"}
+// Response (single archive)
+{"download_url": "https://...", "filename": "spaceship-titanic_data.zip", "message": "..."}
+// Response (multiple files)
+{"files": [{"name": "train.csv", "url": "https://..."}, ...], "message": "..."}
+```
+
+---
+
+#### `aicodinggym mle submit COMPETITION_ID -F FILE`
+
+Upload prediction CSV for scoring.
+
+```
+aicodinggym mle submit COMPETITION_ID -F FILE [--user-id ID] [--message MSG]
+```
+
+| Option | Required | Description |
+|---|---|---|
+| `-F` | Yes | Path to prediction CSV file |
+| `--message, -m` | No | Submission description |
+
+**Backend API:** `POST /api/mlebench/submit` (multipart form)
+```
+POST /api/mlebench/submit
+Content-Type: multipart/form-data
+
+user_id=alice123
+competition_id=spaceship-titanic
+file=@predictions.csv
+```
+```json
+// Response
+{"message": "Submission received", "score": 0.85}
+```
+
+---
+
+## File Structure
+
+```
+src/aicodinggym/
+├── __init__.py      # Version
+├── cli.py           # Click CLI commands (entry point)
+├── config.py        # Config + credentials persistence (~/.aicodinggym/)
+├── api.py           # HTTP client for aicodinggym.com/api
+└── git_ops.py       # SSH key generation, git clone/commit/push/reset
+```
+
+## Configuration Files
+
+| File | Purpose |
+|---|---|
+| `~/.aicodinggym/config.json` | Global config (user_id, repo_name, key path, workspace) |
+| `~/.aicodinggym/credentials.json` | Per-problem credentials (repo_url, branch, cached after fetch) |
+| `~/.aicodinggym/{user_id}_id_rsa` | SSH private key |
+| `~/.aicodinggym/{user_id}_id_rsa.pub` | SSH public key |
+
+## Error Handling
+
+All errors print actionable messages guiding the user (or LLM agent) to the correct next step:
+
+- **Not configured** → "Run 'aicodinggym configure --user-id YOUR_USER_ID' first."
+- **Not fetched** → "You must fetch the problem first: aicodinggym swe fetch PROBLEM_ID"
+- **API unreachable** → "Cannot connect to https://aicodinggym.com/api. Check your internet connection."
+- **User ID mismatch** → "Problem was fetched by 'X', not 'Y'. Either use --user-id X or re-fetch."
+
+## Backend API Summary
+
+| Endpoint | Method | Used By |
+|---|---|---|
+| `/api/configure` | POST | `configure` |
+| `/api/fetch-problem` | POST | `swe fetch` |
+| `/api/submissions` | POST | `swe submit` |
+| `/api/mlebench/download` | POST | `mle download` |
+| `/api/mlebench/submit` | POST | `mle submit` |

aicodinggym_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+aicodinggym/__init__.py,sha256=UJpUmTsBbxwk9-wc0hE9Z8AmBjM06zjL5IY_YfHNdeU,48
+aicodinggym/api.py,sha256=Fxf_W8Loz2R4mlCx4UamQJq7JrxNVpwpXrUWSIvrbZ0,4948
+aicodinggym/cli.py,sha256=QX-tBzF0ReIunl2GuJTNk1ZUiNT0u91GPvaqMaPWn8U,21387
+aicodinggym/config.py,sha256=9jlHh7VQnLKEBxnh8OL0KiN5-SMzI4rZ9sl-HN4P8JU,2684
+aicodinggym/git_ops.py,sha256=NVNdpp_X2yKlKabH8honQ5dbA_4h82ZoNV2eKumDCXs,6831
+aicodinggym_cli-0.1.0.dist-info/METADATA,sha256=2ObygkkQ7Lk0e2x5JlWVhA_Oliw8nIlyGKFzB9tkLbE,6011
+aicodinggym_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+aicodinggym_cli-0.1.0.dist-info/entry_points.txt,sha256=IT2fCKaEBbaBggkEVid2lMBtOsxc_xKDWl55jagRjGs,53
+aicodinggym_cli-0.1.0.dist-info/top_level.txt,sha256=U7rm2fKrhxYDwglsV3qYwok7DiqyO4iTLXyDE-2rDNc,12
+aicodinggym_cli-0.1.0.dist-info/RECORD,,

aicodinggym_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aicodinggym_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aicodinggym = aicodinggym.cli:main

aicodinggym_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aicodinggym