llmboost-hub 0.1.1__py3-none-any.whl

llmboost_hub/cli.py

@@ -0,0 +1,47 @@
+import click
+
+from llmboost_hub.commands import (
+    attach,
+    completions,
+    list as list_cmd,
+    login,
+    prep,
+    run,
+    search,
+    serve,
+    status as status_cmd,
+    stop,
+    test_cmd,
+    tune,
+)
+from importlib import metadata
+
+pkg_name = __package__ or "llmboost_hub"
+pkg_version = metadata.version(pkg_name)
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(version=pkg_version, package_name=pkg_name, message="llmboost_hub (lbh) version %(version)s")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose mode.")
+@click.pass_context
+def main(ctx: click.Context, verbose):
+    """LLMBoost Hub (lbh): Manage LLMBoost model containers and environments to run, serve, and tune large language models."""
+    ctx.ensure_object(dict)
+    ctx.obj["VERBOSE"] = verbose
+
+
+# Register commands
+main.add_command(attach.attach)
+main.add_command(completions.completions)
+main.add_command(list_cmd.list_models)
+main.add_command(login.login)
+main.add_command(prep.prep)
+main.add_command(run.run)
+main.add_command(search.search)
+main.add_command(serve.serve)
+main.add_command(status_cmd.status_cmd)
+main.add_command(stop.stop)
+main.add_command(test_cmd.test_cmd)
+main.add_command(tune.tune)
+
+if __name__ == "__main__":
+    main()

llmboost_hub/commands/attach.py

@@ -0,0 +1,74 @@
+import click
+import subprocess
+
+from llmboost_hub.utils.container_utils import (
+    container_name_for_model,
+    is_container_running,
+)
+from llmboost_hub.commands.completions import complete_model_names
+
+
+def do_attach(model: str | None, container: str | None, verbose: bool = False) -> dict:
+    """
+    Attach to a running container and open an interactive shell (bash -> sh fallback).
+
+    Args:
+        model: Model identifier used to derive container name when 'container' is not provided.
+        container: Explicit container name to attach to.
+        verbose: If True, echo informative messages.
+
+    Returns:
+        Dict: {returncode: int, container_name: str, error: str|None}
+    """
+    cname = container or (container_name_for_model(model) if model else None)
+    if not cname:
+        return {"returncode": 1, "container_name": "", "error": "No model or container specified."}
+
+    # Early return if target is not running
+    if not is_container_running(cname):
+        return {
+            "returncode": 1,
+            "container_name": cname,
+            "error": f"Container '{cname}' is not running.",
+        }
+
+    # Prefer bash; fall back to sh on failure
+    exec_cmd = ["docker", "exec", "-it", cname, "bash"]
+    if verbose:
+        click.echo(f"[attach] Opening shell in container '{cname}'...")
+    try:
+        subprocess.run(exec_cmd, check=True)
+        return {"returncode": 0, "container_name": cname, "error": None}
+    except subprocess.CalledProcessError:
+        exec_cmd = ["docker", "exec", "-it", cname, "/bin/sh"]
+        try:
+            subprocess.run(exec_cmd, check=True)
+            return {"returncode": 0, "container_name": cname, "error": None}
+        except subprocess.CalledProcessError as e:
+            return {
+                "returncode": e.returncode,
+                "container_name": cname,
+                "error": f"Attach failed (exit {e.returncode})",
+            }
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("model", required=False, shell_complete=complete_model_names)
+@click.option(
+    "-c",
+    "--container",
+    "container",
+    type=str,
+    help="Container name to attach to (overrides model).",
+)
+@click.pass_context
+def attach(ctx: click.Context, model, container):
+    """
+    Attach to a running model container and open a shell.
+
+    Equivalent to 'docker exec -it <container> bash'.
+    """
+    verbose = ctx.obj.get("VERBOSE", False)
+    res = do_attach(model, container, verbose=verbose)
+    if res["returncode"] != 0:
+        raise click.ClickException(res["error"] or "Attach failed")

llmboost_hub/commands/chat.py

@@ -0,0 +1,62 @@
+import click
+import subprocess
+
+from llmboost_hub.utils.container_utils import (
+    container_name_for_model,
+    is_container_running,
+)
+from llmboost_hub.commands.run import do_run
+from llmboost_hub.commands.completions import complete_model_names
+
+
+def do_chat(model: str, verbose: bool = False) -> dict:
+    """
+    Ensure a container is running, then exec `llmboost chat --model_name <model>`.
+
+    Args:
+        model: Target model identifier.
+        verbose: If True, echo docker exec command.
+
+    Returns:
+        Dict: {returncode: int, container_name: str, error: str|None}
+    """
+    cname = container_name_for_model(model)
+    if not is_container_running(cname):
+        if verbose:
+            click.echo(f"[chat] No running container for {model}; starting via lbh run...")
+        res = do_run(model, lbh_workspace=None, docker_args=(), verbose=verbose)
+        if res["returncode"] != 0:
+            return {"returncode": res["returncode"], "container_name": "", "error": res["error"]}
+    # Re-check after attempting to start container
+    if not is_container_running(cname):
+        return {
+            "returncode": 1,
+            "container_name": "",
+            "error": "Failed to start container for chat.",
+        }
+
+    exec_cmd = ["docker", "exec", "-it", cname, "llmboost", "chat", "--model_name", model]
+    if verbose:
+        click.echo("[chat] " + " ".join(exec_cmd))
+    try:
+        subprocess.run(exec_cmd, check=True)
+        return {"returncode": 0, "container_name": cname, "error": None}
+    except subprocess.CalledProcessError as e:
+        return {
+            "returncode": e.returncode,
+            "container_name": cname,
+            "error": f"Failed to start chat (exit {e.returncode})",
+        }
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("model", required=True, shell_complete=complete_model_names)
+@click.pass_context
+def chat(ctx: click.Context, model):
+    """
+    Start an interactive chat session inside the model container.
+    """
+    verbose = ctx.obj.get("VERBOSE", False)
+    res = do_chat(model, verbose=verbose)
+    if res["returncode"] != 0:
+        raise click.ClickException(res["error"] or "Chat failed")

llmboost_hub/commands/completions.py

@@ -0,0 +1,238 @@
+import click
+import os
+
+from llmboost_hub.commands.search import do_search
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option("0.1.0")
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose mode.")
+@click.pass_context
+def main(ctx: click.Context, verbose):
+    """LLMBoost Hub (lbh): Manage LLMBoost model containers and environments."""
+    ctx.ensure_object(dict)
+    ctx.obj["VERBOSE"] = verbose
+
+
+def _detect_shell() -> str:
+    """
+    Detect the current shell from environment variables.
+
+    Returns:
+        One of: 'bash', 'zsh', 'fish', or 'powershell' (best-effort; defaults to bash).
+    """
+    sh = os.environ.get("SHELL", "")
+    base = os.path.basename(sh).lower()
+    if "zsh" in base:
+        return "zsh"
+    if "fish" in base:
+        return "fish"
+    if "bash" in base:
+        return "bash"
+    # Best-effort: allow powershell if on Windows session
+    if os.environ.get("PSModulePath"):
+        return "powershell"
+    return "bash"
+
+
+def _one_liner(shell: str, prog: str = "lbh") -> str:
+    """
+    Return the eval one-liner to enable Click completions for a shell.
+
+    Args:
+        shell: Target shell.
+        prog: CLI executable name (default: 'lbh').
+    """
+    var = f"_{prog.upper()}_COMPLETE"
+    if shell == "bash":
+        return f'eval "$({var}=bash_source {prog})"'
+    if shell == "zsh":
+        return f'eval "$({var}=zsh_source {prog})"'
+    if shell == "fish":
+        return f'eval "$({var}=fish_source {prog})"'
+    if shell == "powershell":
+        return f'$Env:{var}="powershell_source"; {prog} | Out-String | Invoke-Expression'
+    # default bash
+    return f'eval "$({var}=bash_source {prog})"'
+
+
+def _default_profile_path(shell: str) -> str:
+    """
+    Return the default profile file path for a given shell.
+
+    Args:
+        shell: Target shell.
+
+    Returns:
+        Path to rc/profile file where completions should be persisted.
+    """
+    home = os.path.expanduser("~")
+    if shell == "bash":
+        return os.path.join(home, ".bashrc")
+    if shell == "zsh":
+        return os.path.join(home, ".zshrc")
+    if shell == "fish":
+        return os.path.join(home, ".config", "fish", "config.fish")
+    if shell == "powershell":
+        # Prefer $PROFILE if available
+        return os.environ.get("PROFILE") or os.path.join(
+            home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1"
+        )
+    return os.path.join(home, ".bashrc")
+
+
+def _venv_activation_targets(venv_root: str, shell: str | None = None) -> list[tuple[str, str]]:
+    """
+    Return (shell_key, path) tuples for activation files in a virtualenv.
+
+    Args:
+        venv_root: Root path of the active virtualenv.
+        shell: Optional single shell to target; when None, include all detected.
+
+    Returns:
+        List of (shell_key, file_path) pairs to update.
+    """
+    targets = []
+    if shell in (None, "bash", "zsh"):
+        bash_path = os.path.join(venv_root, "bin", "activate")
+        zsh_path = os.path.join(venv_root, "bin", "activate.zsh")
+        targets.append(("bash/zsh", bash_path))
+        targets.append(("zsh", zsh_path))
+    if shell in (None, "fish"):
+        fish_path = os.path.join(venv_root, "bin", "activate.fish")
+        targets.append(("fish", fish_path))
+    if shell in (None, "powershell"):
+        ps_path = os.path.join(venv_root, "Scripts", "Activate.ps1")
+        targets.append(("powershell", ps_path))
+    return targets
+
+
+def _write_block(file_path: str, content: str, start_tag: str, end_tag: str) -> None:
+    """
+    Idempotently write a tagged content block to a file.
+
+    Behavior:
+        - Removes any existing block between start_tag and end_tag.
+        - Appends a fresh block to the end of the file (creating the file if needed).
+
+    Args:
+        file_path: Destination file path.
+        content: Text content to write between tags.
+        start_tag: Start marker line.
+        end_tag: End marker line.
+
+    Raises:
+        ClickException: When writing fails.
+    """
+    try:
+        existing = ""
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as fh:
+                existing = fh.read()
+        # Remove existing block if present
+        import re as _re
+
+        pattern = _re.compile(
+            _re.escape(start_tag) + r".*?" + _re.escape(end_tag), flags=_re.DOTALL
+        )
+        cleaned = _re.sub(pattern, "", existing).rstrip()
+        # Append new block
+        new_text = (
+            (cleaned + "\n\n" if cleaned else "")
+            + start_tag
+            + "\n"
+            + content
+            + "\n"
+            + end_tag
+            + "\n"
+        )
+        os.makedirs(os.path.dirname(os.path.abspath(file_path)), exist_ok=True)
+        with open(file_path, "w", encoding="utf-8") as fh:
+            fh.write(new_text)
+    except Exception as e:
+        raise click.ClickException(f"Failed to update '{file_path}': {e}")
+
+
+# completion helper for model names (uses the same source as `lbh list`)
+def complete_model_names(ctx: click.Context, param: click.Parameter, query: str = r".*"):
+    """
+    Shell completion callback returning model names discovered by `do_search` (local_only, names_only).
+
+    Behavior:
+        - Regex, case-insensitive search on `query`.
+    """
+    try:
+        model_names = do_search(query=query, local_only=True, verbose=False, names_only=True)[
+            "model"
+        ]
+        return model_names.dropna().astype(str).unique().tolist()
+    except Exception:
+        return []
+
+
+@click.command(name="completions", context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "--shell",
+    type=click.Choice(["bash", "zsh", "fish", "powershell"]),
+    default=None,
+    help="Target shell (default: auto-detect).",
+)
+@click.option(
+    "--profile",
+    is_flag=True,
+    help="Append completion to the detected shell profile (~/.bashrc, ~/.zshrc, fish config, or PowerShell profile).",
+)
+@click.option(
+    "--venv",
+    is_flag=True,
+    help="Append completion to the active virtualenv activation file(s). If shell not specified, updates all present.",
+)
+@click.pass_context
+def completions(ctx: click.Context, shell, profile, venv):
+    """
+    Manage shell completions.
+
+    Usage:
+        - Print a temporary one-liner for eval (no file modification).
+        - Optionally persist to shell profile and/or virtualenv activation files.
+    """
+    sh = shell or _detect_shell()
+
+    # No persistence flags -> print the one-liner for eval in the current shell
+    if not profile and not venv:
+        click.echo(_one_liner(sh, "lbh"))
+        return
+
+    # Profile persistence
+    if profile:
+        profile_path = _default_profile_path(sh)
+        line = _one_liner(sh, "lbh")
+        start_tag = "# >>> lbh shell completion start"
+        end_tag = "# <<< lbh shell completion end"
+        _write_block(os.path.expanduser(profile_path), line, start_tag, end_tag)
+        click.echo(f"Updated profile: {os.path.expanduser(profile_path)}")
+
+    # Venv persistence
+    if venv:
+        venv_root = os.environ.get("VIRTUAL_ENV", "")
+        if not venv_root:
+            raise click.ClickException("No active virtualenv detected (VIRTUAL_ENV is not set).")
+        targets = _venv_activation_targets(venv_root, shell=sh if shell else None)
+        updated = []
+        start_tag = "# >>> lbh venv completion start"
+        end_tag = "# <<< lbh venv completion end"
+        for shell_key, path in targets:
+            if os.path.exists(path):
+                line = (
+                    _one_liner("bash", "lbh")
+                    if shell_key == "bash/zsh"
+                    else _one_liner(shell_key, "lbh")
+                )
+                _write_block(path, line, start_tag, end_tag)
+                updated.append(path)
+        if not updated:
+            raise click.ClickException(
+                "No matching activation files found in the current virtualenv."
+            )
+        for p in updated:
+            click.echo(f"Updated venv activation: {p}")