olmon 0.1.0__tar.gz

olmon-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vlad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

olmon-0.1.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: olmon
+Version: 0.1.0
+Summary: A lightweight CLI to monitor Ollama models and usage
+Author-email: Vlad Digori <digorivlad59@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/glemiu6/olmon
+Project-URL: Repository, https://github.com/glemiu6/olmon
+Project-URL: Bug Tracker, https://github.com/glemiu6/olmon/issues
+Keywords: ollama,monitor,cli,llm,devops,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mypy>=2.1.0
+Requires-Dist: platformdirs>=4.10.0
+Requires-Dist: rich>=15.0.0
+Dynamic: license-file
+
+# olmon
+
+A lightweight CLI to monitor your Ollama models and usage in real time.
+
+```
+$ olmon watch
+Watching http://localhost:11434 every 2s — Ctrl+C to stop
+
+  🟢 Ollama v0.30.8 — 14 models installed, 2 running
+
+  ┏━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━┓
+  ┃ Name            ┃ Size   ┃ VRAM   ┃ Expires At   ┃
+  ┡━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━┩
+  │ llama3.2:latest │ 2.4 GB │ 2.4 GB │ 2026-06-23   │
+  │ qwen2.5:7b      │ 4.4 GB │ 4.4 GB │ 2026-06-23   │
+  └─────────────────┴────────┴────────┴──────────────┘
+```
+
+---
+
+## Features
+
+- 🔄 **Real-time dashboard** — live auto-refreshing view of running models
+- 📋 **Model listing** — browse all installed models with size, family, and quantization
+- 🔍 **Model inspection** — full details on any installed model
+- 🟢 **Status indicators** — green / blue / red at a glance
+- ⚙️ **Configurable** — set your API host and refresh interval
+- 🪶 **Lightweight** — minimal dependencies, works over SSH on headless servers
+
+---
+
+## Requirements
+
+- Python 3.13+
+- [Ollama](https://ollama.com) installed and running
+
+---
+
+## Installation
+
+### pip
+
+```bash
+pip install olmon
+```
+
+### curl (Linux / macOS)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/glemiu6/olmon/master/scripts/install.sh | sh
+```
+
+### From source
+
+```bash
+git clone https://github.com/glemiu6/olmon.git
+cd olmon
+uv pip install -e .
+```
+### Windows
+
+Native Windows binary is not currently supported.
+Use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) and follow the Linux installation instructions.
+---
+
+## Usage
+
+```bash
+olmon status               # quick health check
+olmon models               # list all installed models
+olmon models --sort size   # sort by size
+olmon models --filter llama  # filter by name or family
+olmon inspect llama3:latest  # full details on a model
+olmon ps                   # show currently running models
+olmon watch                # live auto-refreshing dashboard
+olmon watch --interval 5   # refresh every 5 seconds
+```
+
+### Global flags
+
+```bash
+olmon --host http://192.168.1.10:11434 status   # connect to remote Ollama
+olmon --version                                  # print version
+```
+
+---
+
+## Status Indicators
+
+| Indicator | Meaning |
+|-----------|---------|
+| 🟢 Green  | Models are loaded and running |
+| 🔵 Blue   | Ollama is idle, no models loaded |
+| 🔴 Red    | Ollama is offline or unreachable |
+
+---
+
+## Configuration
+
+```bash
+olmon init          # create default config file
+olmon config show   # view current config
+```
+
+Config is stored at `~/.config/olmon/config.json`:
+
+```json
+{
+  "host": "http://localhost:11434",
+  "interval": 2,
+  "no_color": false,
+  "default_sort": "name"
+}
+```
+
+---
+
+## Update & Uninstall
+
+```bash
+olmon update      # update to latest version
+olmon uninstall   # remove olmon and config
+```
+
+---
+
+## Why olmon?
+
+Most Ollama monitoring tools are GUI or system tray apps. `olmon` is built for:
+
+- **Headless Linux servers** — no GUI required
+- **Remote monitoring** — works over SSH
+- **Shell scripting** — pipe-friendly with `--json` flag and exit codes
+- **DevOps workflows** — integrate into scripts and cron jobs
+
+---
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) for the full plan.
+
+---
+
+## Contributing
+
+Contributions are welcome. Feel free to open an issue or submit a pull request.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.
+
+---
+
+Made with ❤️ by [Vlad Digori](https://github.com/glemiu6)

olmon-0.1.0/README.md

@@ -0,0 +1,156 @@
+# olmon
+
+A lightweight CLI to monitor your Ollama models and usage in real time.
+
+```
+$ olmon watch
+Watching http://localhost:11434 every 2s — Ctrl+C to stop
+
+  🟢 Ollama v0.30.8 — 14 models installed, 2 running
+
+  ┏━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━┓
+  ┃ Name            ┃ Size   ┃ VRAM   ┃ Expires At   ┃
+  ┡━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━┩
+  │ llama3.2:latest │ 2.4 GB │ 2.4 GB │ 2026-06-23   │
+  │ qwen2.5:7b      │ 4.4 GB │ 4.4 GB │ 2026-06-23   │
+  └─────────────────┴────────┴────────┴──────────────┘
+```
+
+---
+
+## Features
+
+- 🔄 **Real-time dashboard** — live auto-refreshing view of running models
+- 📋 **Model listing** — browse all installed models with size, family, and quantization
+- 🔍 **Model inspection** — full details on any installed model
+- 🟢 **Status indicators** — green / blue / red at a glance
+- ⚙️ **Configurable** — set your API host and refresh interval
+- 🪶 **Lightweight** — minimal dependencies, works over SSH on headless servers
+
+---
+
+## Requirements
+
+- Python 3.13+
+- [Ollama](https://ollama.com) installed and running
+
+---
+
+## Installation
+
+### pip
+
+```bash
+pip install olmon
+```
+
+### curl (Linux / macOS)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/glemiu6/olmon/master/scripts/install.sh | sh
+```
+
+### From source
+
+```bash
+git clone https://github.com/glemiu6/olmon.git
+cd olmon
+uv pip install -e .
+```
+### Windows
+
+Native Windows binary is not currently supported.
+Use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) and follow the Linux installation instructions.
+---
+
+## Usage
+
+```bash
+olmon status               # quick health check
+olmon models               # list all installed models
+olmon models --sort size   # sort by size
+olmon models --filter llama  # filter by name or family
+olmon inspect llama3:latest  # full details on a model
+olmon ps                   # show currently running models
+olmon watch                # live auto-refreshing dashboard
+olmon watch --interval 5   # refresh every 5 seconds
+```
+
+### Global flags
+
+```bash
+olmon --host http://192.168.1.10:11434 status   # connect to remote Ollama
+olmon --version                                  # print version
+```
+
+---
+
+## Status Indicators
+
+| Indicator | Meaning |
+|-----------|---------|
+| 🟢 Green  | Models are loaded and running |
+| 🔵 Blue   | Ollama is idle, no models loaded |
+| 🔴 Red    | Ollama is offline or unreachable |
+
+---
+
+## Configuration
+
+```bash
+olmon init          # create default config file
+olmon config show   # view current config
+```
+
+Config is stored at `~/.config/olmon/config.json`:
+
+```json
+{
+  "host": "http://localhost:11434",
+  "interval": 2,
+  "no_color": false,
+  "default_sort": "name"
+}
+```
+
+---
+
+## Update & Uninstall
+
+```bash
+olmon update      # update to latest version
+olmon uninstall   # remove olmon and config
+```
+
+---
+
+## Why olmon?
+
+Most Ollama monitoring tools are GUI or system tray apps. `olmon` is built for:
+
+- **Headless Linux servers** — no GUI required
+- **Remote monitoring** — works over SSH
+- **Shell scripting** — pipe-friendly with `--json` flag and exit codes
+- **DevOps workflows** — integrate into scripts and cron jobs
+
+---
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) for the full plan.
+
+---
+
+## Contributing
+
+Contributions are welcome. Feel free to open an issue or submit a pull request.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.
+
+---
+
+Made with ❤️ by [Vlad Digori](https://github.com/glemiu6)

olmon-0.1.0/olmon/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

olmon-0.1.0/olmon/__main__.py

@@ -0,0 +1,4 @@
+from olmon.main import app
+
+if __name__ == "__main__":
+    app()

olmon-0.1.0/olmon/client.py

@@ -0,0 +1,55 @@
+import json
+import urllib.request
+
+
+def get_version(host: str) -> dict | None:
+    """
+    Fetches the version information of the Ollama API
+    """
+    try:
+        with urllib.request.urlopen(f"{host}/api/version") as r:
+            return json.loads(r.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def get_models(host: str) -> dict | None:
+    """
+    Fetches the list of the local models available via Ollama API
+    """
+    try:
+        with urllib.request.urlopen(f"{host}/api/tags") as r:
+            return json.loads(r.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def get_running(host: str) -> dict | None:
+    """
+    Fetches the running models running via Ollama API
+    """
+    try:
+        with urllib.request.urlopen(f"{host}/api/ps") as r:
+            return json.loads(r.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def get_model_info(host: str, model_name: str) -> dict | None:
+    """
+    Fetches the information of a specific model via Ollama API
+    """
+    try:
+        data = json.dumps({"model": model_name}).encode("utf-8")
+
+        req = urllib.request.Request(
+            url=f"{host}/api/show",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        with urllib.request.urlopen(req) as result:
+            return json.loads(result.read().decode("utf-8"))
+    except Exception:
+        return None

olmon-0.1.0/olmon/commands/init.py

@@ -0,0 +1,30 @@
+import os
+
+from platformdirs import user_config_dir
+
+from olmon.config import OlmonConfig
+
+APP_NAME = "olmon"
+
+
+def get_default_config_path() -> str:
+    config_dir = user_config_dir(APP_NAME)
+    os.makedirs(config_dir, exist_ok=True)
+    return os.path.join(config_dir, "config.json")
+
+
+def init_config() -> None:
+    paths = get_default_config_path()
+    if os.path.exists(paths):
+        choice = input("Config file already exists. Overwrite? (y/n): ").lower()
+        if choice != "y":
+            return
+
+    host = input("Ollama host [http://localhost:11434]: ") or "http://localhost:11434"
+    interval = input("Update interval [2]: ") or 2
+    no_color = input("Disable color [False]: ") or False
+    default_sort = input("Default sort [name]: ") or "name"
+
+    cfg = OlmonConfig(host, int(interval), bool(no_color), default_sort)
+    cfg.save()
+    print("Config file created at", paths)

olmon-0.1.0/olmon/commands/models.py

@@ -0,0 +1,49 @@
+from olmon.config import OlmonConfig
+from olmon.display import print_error, print_offline
+
+
+def models_command(host: str | None = None, sort: str | None = None, filters: str | None = None):
+    from olmon.client import get_models
+    from olmon.display import print_models_table
+
+    config = OlmonConfig.load()
+    resolved_host = host or config.host
+    raw = get_models(resolved_host)
+    if raw is None:
+        print_offline(resolved_host)
+        return
+    if "models" not in raw:
+        print_error("unexpected response from Ollama API")
+    models = raw["models"]
+
+    if filters:
+        models = [m for m in models if filters.lower() in m["name"].lower()]
+    sort_key = sort or config.default_sort
+    if sort_key == "size":
+        models = sorted(models, key=lambda x: x["size"], reverse=True)
+    elif sort_key == "date":
+        models = sorted(models, key=lambda x: x["modified_at"], reverse=True)
+    else:
+        models = sorted(models, key=lambda x: x["name"])
+
+    print_models_table(models)
+
+
+def inspect_command(host: str | None = None, name: str | None = None):
+    from olmon.client import get_model_info
+    from olmon.display import print_inspect
+
+    config = OlmonConfig.load()
+    resolved_host = host or config.host
+
+    if name is None:  # ← guard against None before passing to client
+        print_error("Model name is required")
+        return
+
+    data = get_model_info(resolved_host, name)
+
+    if data is None:
+        print_error(f"Could not fetch info for '{name}'")
+        return
+
+    print_inspect(data)

olmon-0.1.0/olmon/commands/ps.py

@@ -0,0 +1,18 @@
+from olmon.client import get_running
+from olmon.config import OlmonConfig
+from olmon.display import print_error, print_offline, print_ps_table
+
+
+def ps_command(host: str | None = None):
+    config = OlmonConfig.load()
+    resolved_host = host or config.host
+    raw = get_running(resolved_host)
+    if raw is None:
+        print_offline(resolved_host)
+        return
+    models = raw.get("models", [])
+
+    if not models:
+        print_error("No models are running")
+        return
+    print_ps_table(models)

olmon-0.1.0/olmon/commands/status.py

@@ -0,0 +1,26 @@
+from olmon import client, display
+from olmon.config import OlmonConfig
+
+
+def status_command(host: str | None = None):
+    config = OlmonConfig.load()
+    resolved_host = host or config.host
+
+    version_data = client.get_version(resolved_host)
+
+    if version_data is None:
+        display.print_offline(resolved_host)
+        return
+
+    models_data = client.get_models(resolved_host)
+    running_data = client.get_running(resolved_host)
+
+    total = len(models_data["models"]) if models_data else 0
+    running = len(running_data["models"]) if running_data else 0
+
+    display.print_status(
+        version=version_data["version"],
+        host=resolved_host,
+        total_models=total,
+        running_models=running,
+    )

olmon-0.1.0/olmon/commands/uninstall.py

@@ -0,0 +1,76 @@
+# olmon/commands/uninstall.py
+def uninstall() -> None:
+    """Remove olmon completely = pip, binary, and config."""
+    import os
+    import shutil
+    import subprocess
+    import sys
+
+    from rich.console import Console
+
+    console = Console()
+
+    console.print("[bold red]Uninstalling olmon...[/bold red]")
+    method = _detect_install_method()
+
+    # Remove config file
+    config_path = os.path.expanduser("~/.config/olmon")
+    if os.path.exists(config_path):
+        shutil.rmtree(config_path)
+        console.print("[green]Removed ~/.config/olmon[/green]")
+
+    if sys.platform == "win32":
+        windows_path = os.path.join(os.environ.get("LOCALAPPDATA", ""), "komit")
+        if os.path.exists(windows_path):
+            shutil.rmtree(windows_path)
+            console.print(f"[green]Removed {windows_path}[/green]")
+        try:
+            import winreg
+
+            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment", 0, winreg.KEY_ALL_ACCESS)
+            current_path, _ = winreg.QueryValueEx(key, "Path")
+            new_path = ";".join(p for p in current_path.split(";") if "komit" not in p)
+            winreg.SetValueEx(key, "Path", 0, winreg.REG_EXPAND_SZ, new_path)
+            winreg.CloseKey(key)
+            console.print("[green]Removed from PATH[/green]")
+        except Exception as e:
+            console.print(f"[yellow]Could not remove from PATH: {e}[/yellow]")
+    # Remove binary if installed via curl
+    all_paths = ["~/.local/bin/olmon", "/usr/local/bin/olmon", "/opt/homebrew/bin/olmon"]
+
+    for p in all_paths:
+        binary = os.path.expanduser(p)
+        if os.path.exists(binary):
+            try:
+                subprocess.run(["sudo", "rm", "-f", binary], check=True)
+                console.print(f"[green]Removed {binary}[/green]")
+            except subprocess.CalledProcessError:
+                console.print(f"[yellow]Failed to remove {binary} - try: sudo rm {binary}[/yellow]")
+    # remove for pip
+    if method == "pip":
+        try:
+            subprocess.run([sys.executable, "-m", "pip", "uninstall", "olmon", "-y"], check=False)
+            console.print("[green]Removed pip package[/green]")
+        except subprocess.CalledProcessError:
+            pass
+
+    console.print("\n[bold red]komit uninstalled. Goodbye![/bold red]")
+
+
+def _detect_install_method() -> str:
+    import importlib.metadata
+    import sys
+
+    # 1. PyInstaller / bundled binary
+    if getattr(sys, "frozen", False):
+        return "binary"
+
+    # 2. pip install (most reliable check)
+    try:
+        importlib.metadata.version("olmon")
+        return "pip"
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+    # 3. fallback
+    return "binary"

olmon-0.1.0/olmon/commands/update.py

@@ -0,0 +1,110 @@
+# olmon/commands/update.py
+import importlib.metadata
+import json
+import subprocess
+import sys
+
+from rich.console import Console
+
+from olmon import __version__
+
+console = Console()
+
+
+def _get_latest_version() -> str | None:
+    import urllib.request
+
+    for url, extract in [
+        (
+            "https://api.github.com/repos/glemiu6/olmon/releases/latest",
+            lambda d: d["tag_name"].lstrip("v"),
+        ),
+        (
+            "https://pypi.org/pypi/olmon/json",
+            lambda d: d["info"]["version"],
+        ),
+    ]:
+        try:
+            with urllib.request.urlopen(url, timeout=2) as r:
+                return extract(json.loads(r.read().decode("utf-8")))
+        except Exception:
+            continue
+
+    return None
+
+
+def check_for_update() -> None:
+    try:
+        latest_version = _get_latest_version()
+        if latest_version is None:
+            return
+        if latest_version != __version__:
+            console.print(
+                f"\n[bold yellow]!! New version available: v{latest_version}[/bold yellow] [dim](you have v{__version__})[/dim]"  # noqa: E501
+            )
+            console.print("[dim]    Use: olmon update[/dim]\n")
+    except Exception:
+        pass
+
+
+def _detect_install_method() -> str:
+    if getattr(sys, "frozen", False):
+        return "binary"
+
+    try:
+        importlib.metadata.version("olmon")
+        return "pip"
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+    return "binary"
+
+
+def update():
+    try:
+        import importlib.util
+
+        latest = _get_latest_version()
+        if latest is None:
+            return
+        if latest == __version__:
+            console.print("[bold green]Already up to date[/bold green]")
+            return
+        console.print(
+            f"\n[bold yellow]!! New version available: v{latest}[/bold yellow] [dim](you have v{__version__})[/dim]"  # noqa: E501
+        )
+        console.print("[dim]    Use: olmon update[/dim]\n")
+        method = _detect_install_method()
+        match method:
+            case "pip":
+                console.print("Detected pip installation, updating...")
+                if importlib.util.find_spec("pip") is None:
+                    console.print("pip not found, installing...")
+                    subprocess.run([sys.executable, "-m", "ensurepip", "--upgrade"], check=True)
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "olmon", "--upgrade"], check=True
+                )
+            case "binary":
+                console.print("Detected binary installation, updating...")
+                result = subprocess.run(
+                    [
+                        "curl",
+                        "-fsSL",
+                        "https://raw.githubusercontent.com/glemiu6/olmon/master/scripts/install.sh",
+                    ],
+                    capture_output=True,
+                    check=True,
+                )
+                subprocess.run(["bash"], input=result.stdout, check=True)
+            case _:
+                console.print("Unknown installation method, please update manually")
+                console.print(" [cyan]pip install olmon --upgrade[/cyan]")
+                console.print(
+                    " [cyan]curl -fsSL https://raw.githubusercontent.com/glemiu6/olmon/master/scripts/install.sh | sh[/cyan]"  # noqa: E501
+                )  # noqa: E501
+        console.print(
+            "[bold green]Update complete! Restart your terminal to use the latest version.[/bold green]"  # noqa: E501
+        )
+    except Exception as e:
+        console.print(f"[bold red]Failed to update: {e}[/bold red]")
+        sys.exit(1)

olmon-0.1.0/olmon/commands/watch.py

@@ -0,0 +1,58 @@
+import time
+
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from olmon.client import get_models, get_running, get_version
+from olmon.config import OlmonConfig
+from olmon.display import format_size
+
+console = Console()
+
+
+def _build_dashboard(resolved_host: str):
+    version_data = get_version(resolved_host)
+    models_data = get_models(resolved_host)
+    running_data = get_running(resolved_host)
+
+    if version_data is None:
+        table = Table(title="🔴 Ollama Unreachable")
+        return table
+    running = running_data.get("models", []) if running_data else []
+    total = len(models_data.get("models", [])) if models_data else 0
+
+    indicator = "🟢" if running else "🔵"
+    table = Table(
+        title=f"{indicator} Ollama v{version_data['version']} - {total} models installed, {len(running)} running"  # noqa: E501
+    )
+    table.add_column("Name")
+    table.add_column("Size")
+    table.add_column("VRAM")
+    table.add_column("Expires At")
+
+    for model in running:
+        table.add_row(
+            model.get("name", "N/A"),
+            format_size(model.get("size", 0)),
+            format_size(model.get("size_vram", 0)),
+            model.get("expires_at", "N/A"),
+        )
+    return table
+
+
+def watch_command(host: str | None = None, interval: int | None = None):
+    config = OlmonConfig.load()
+    resolved_host = host or config.host
+    resolved_interval = interval or config.interval
+
+    console.print(
+        f"[dim]Watching {resolved_host} every {resolved_interval}s - Ctrl+C to stop[/dim]"
+    )  # noqa: E501
+    try:
+        with Live(refresh_per_second=1) as live:
+            while True:
+                live.update(_build_dashboard(resolved_host))
+                time.sleep(resolved_interval)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopping watch...[/dim]")

olmon-0.1.0/olmon/config.py

@@ -0,0 +1,30 @@
+# olmon/config.py
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+CONFIG_PATH = Path(user_config_dir("olmon")) / "config.json"
+
+
+@dataclass
+class OlmonConfig:
+    host: str = "http://localhost:11434"
+    interval: int = 2
+    no_color: bool = False
+    default_sort: str = "name"
+
+    @classmethod
+    def load(cls):
+        if not CONFIG_PATH.exists():
+            return cls()
+        with open(CONFIG_PATH, "r") as f:
+            data = json.load(f)
+
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+    def save(self):
+        CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with open(CONFIG_PATH, "w") as f:
+            json.dump(asdict(self), f, indent=2)

olmon-0.1.0/olmon/display.py

@@ -0,0 +1,128 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+def print_status(version: str, host: str, total_models: int, running_models: int) -> None:
+    status_color = "green" if running_models > 0 else "blue"
+    indicator = "🟢" if running_models > 0 else "🔵"
+
+    content = (
+        f"[bold]Version[/bold] {version}\n"
+        f"[bold]Host[/bold] {host}\n"
+        f"[bold]Models[/bold] {total_models} installed, {running_models} running\n"
+    )
+    console.print(Panel(content, title=f"{indicator} Ollama is running", border_style=status_color))
+
+
+def print_models_table(models) -> None:
+    table = Table(title="Models")
+    table.add_column("Name")
+    table.add_column("Size")
+    table.add_column("Params")
+    table.add_column("Quantization")
+    table.add_column("Format")
+    for model in models:
+        table.add_row(
+            model["name"],
+            format_size(model["size"]),
+            model["details"].get("parameter_size", "N/A"),
+            model["details"].get("quantization_level", "N/A"),
+            model["details"].get("format", "N/A"),
+        )
+    console.print(table)
+
+
+def print_ps_table(processes) -> None:
+    table = Table(title="Running Models")
+    table.add_column("Name")
+    table.add_column("Size")
+    table.add_column("VRAM")
+    table.add_column("Params")
+    table.add_column("Context Length")
+    table.add_column("Family")
+    table.add_column("Quantization")
+    table.add_column("Expires At")
+
+    for model in processes:
+        table.add_row(
+            model.get("name", "N/A"),
+            format_size(model.get("size", 0)),
+            format_size(model.get("size_vram", 0)),
+            model.get("details", {}).get("parameter_size", "N/A"),
+            str(model.get("context_length", 0)),
+            model.get("details", {}).get("family", "N/A"),
+            model.get("details", {}).get("quantization_level", "N/A"),
+            model.get("expires_at", "N/A"),
+        )
+    console.print(table)
+
+
+def print_error(msg: str) -> None:
+    console.print(f"[bold red]🔴 Error:[/bold red] {msg}")
+
+
+def print_offline(host: str) -> None:
+    status_color = "red"
+    indicator = "🔴"
+    content = (
+        f"[bold]Host[/bold] {host}\n\n"
+        f"Make sure Ollama is running:\n"
+        f"[bold yellow]ollama serve[/bold yellow]\n"
+    )
+    console.print(
+        Panel(content, title=f"{indicator} Ollama is unreachable", border_style=status_color)
+    )
+
+
+def print_inspect(data: dict):
+    details = data.get("details", {})
+    model_info = data.get("model_info", {})
+    capabilities = data.get("capabilities", [])
+
+    # parse parameters string into a dict
+    # "temperature 0.7\nnum_ctx 2048" → {"temperature": "0.7", "num_ctx": "2048"}
+    raw_params = data.get("parameters", "")
+    params = {}
+    for line in raw_params.splitlines():
+        parts = line.split(maxsplit=1)
+        if len(parts) == 2:
+            params[parts[0]] = parts[1]
+
+    # clean up modified_at
+    modified = data.get("modified_at", "—").split("T")[0]
+
+    # find context_length from model_info (key ends with .context_length)
+    context = next((str(v) for k, v in model_info.items() if k.endswith(".context_length")), "—")
+    embedding = next(
+        (str(v) for k, v in model_info.items() if k.endswith(".embedding_length")), "—"
+    )
+    blocks = next((str(v) for k, v in model_info.items() if k.endswith(".block_count")), "—")
+
+    # build the panel content
+    content = (
+        f"[bold]Family[/bold]         {details.get('family', '—')}\n"
+        f"[bold]Format[/bold]         {details.get('format', '—')}\n"
+        f"[bold]Parameters[/bold]     {details.get('parameter_size', '—')}\n"
+        f"[bold]Quantization[/bold]   {details.get('quantization_level', '—')}\n"
+        f"[bold]Modified[/bold]       {modified}\n"
+        f"[bold]Capabilities[/bold]   {', '.join(capabilities) if capabilities else '—'}\n"
+        f"\n"
+        f"[bold]Context[/bold]        {context} tokens\n"
+        f"[bold]Embedding[/bold]      {embedding}\n"
+        f"[bold]Blocks[/bold]         {blocks}\n"
+        f"[bold]Temperature[/bold]    {params.get('temperature', '—')}\n"
+        f"[bold]num_ctx[/bold]        {params.get('num_ctx', '—')}\n"
+    )
+
+    console.print(Panel(content, title=f"[bold]{details.get('family', 'Model')}[/bold]"))
+
+
+def format_size(bts: int) -> str:
+    gb = bts / (1024**3)
+    if gb >= 1:
+        return f"{gb:.1f} GB"
+    mb = bts / (1024**2)
+    return f"{mb:.1f} MB"

olmon-0.1.0/olmon/main.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# olmon/main.py
+import argparse
+import sys
+
+from olmon import __version__
+from olmon.commands.init import init_config
+from olmon.commands.models import inspect_command, models_command
+from olmon.commands.ps import ps_command
+from olmon.commands.status import status_command
+from olmon.commands.uninstall import uninstall
+from olmon.commands.update import check_for_update, update
+from olmon.commands.watch import watch_command
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="olmon",
+        description="A lightweight CLI to monitor Ollama models and usage",
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog="""
+        Examples:
+        $ olmon init
+        $ olmon uninstall
+        $ olmon update
+        $ olmon status
+        $ olmon models --sort size
+        $ olmon ps
+        $ olmon watch --interval 3
+        $ olmon inspect llama3:latest
+        """,
+    )
+    parser.add_argument("--version", action="version", version=f"{__version__}")
+    parser.add_argument(
+        "--host", "-H", default=None, metavar="<url>", help="Ollama API URL (overrides config)"
+    )
+
+    subparsers = parser.add_subparsers(title="Commands", dest="command", metavar="<command>")
+    subparsers.add_parser("init", help="Create default config file")
+    subparsers.add_parser("uninstall", help="Uninstall olmon")
+    subparsers.add_parser("update", help="Update olmon to the latest version")
+    # status
+    subparsers.add_parser("status", help="Show Ollama status")
+
+    # models
+    models_parser = subparsers.add_parser("models", help="List installed models")
+    models_parser.add_argument(
+        "--sort", "-s", default=None, metavar="<field>", help="Sort by: name, size, date"
+    )
+    models_parser.add_argument(
+        "--filter", "-f", default=None, metavar="<query>", help="Filter by name or family"
+    )
+
+    # inspect
+    inspect_parser = subparsers.add_parser("inspect", help="Show details of a model")
+    inspect_parser.add_argument("name", metavar="<name>", help="Model name")
+
+    # ps
+    subparsers.add_parser("ps", help="Show running models")
+
+    # watch
+    watch_parser = subparsers.add_parser("watch", help="Live dashboard")
+    watch_parser.add_argument(
+        "--interval",
+        "-i",
+        default=None,
+        type=int,
+        metavar="<seconds>",
+        help="Refresh rate in seconds",
+    )
+
+    return parser.parse_args(argv)
+
+
+def app():
+
+    args = parse_args()
+    check_for_update()
+
+    match args.command:
+        case "status":
+            status_command(args.host)
+        case "models":
+            models_command(args.host, args.sort, args.filter)
+        case "inspect":
+            inspect_command(args.host, args.name)
+        case "ps":
+            ps_command(args.host)
+        case "watch":
+            watch_command(args.host, args.interval)
+        case "init":
+            init_config()
+        case "uninstall":
+            uninstall()
+        case "update":
+            update()
+        case _:
+            parse_args(["--help"])
+            sys.exit(0)
+
+
+if __name__ == "__main__":
+    app()

olmon-0.1.0/olmon.egg-info/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: olmon
+Version: 0.1.0
+Summary: A lightweight CLI to monitor Ollama models and usage
+Author-email: Vlad Digori <digorivlad59@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/glemiu6/olmon
+Project-URL: Repository, https://github.com/glemiu6/olmon
+Project-URL: Bug Tracker, https://github.com/glemiu6/olmon/issues
+Keywords: ollama,monitor,cli,llm,devops,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mypy>=2.1.0
+Requires-Dist: platformdirs>=4.10.0
+Requires-Dist: rich>=15.0.0
+Dynamic: license-file
+
+# olmon
+
+A lightweight CLI to monitor your Ollama models and usage in real time.
+
+```
+$ olmon watch
+Watching http://localhost:11434 every 2s — Ctrl+C to stop
+
+  🟢 Ollama v0.30.8 — 14 models installed, 2 running
+
+  ┏━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━┓
+  ┃ Name            ┃ Size   ┃ VRAM   ┃ Expires At   ┃
+  ┡━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━┩
+  │ llama3.2:latest │ 2.4 GB │ 2.4 GB │ 2026-06-23   │
+  │ qwen2.5:7b      │ 4.4 GB │ 4.4 GB │ 2026-06-23   │
+  └─────────────────┴────────┴────────┴──────────────┘
+```
+
+---
+
+## Features
+
+- 🔄 **Real-time dashboard** — live auto-refreshing view of running models
+- 📋 **Model listing** — browse all installed models with size, family, and quantization
+- 🔍 **Model inspection** — full details on any installed model
+- 🟢 **Status indicators** — green / blue / red at a glance
+- ⚙️ **Configurable** — set your API host and refresh interval
+- 🪶 **Lightweight** — minimal dependencies, works over SSH on headless servers
+
+---
+
+## Requirements
+
+- Python 3.13+
+- [Ollama](https://ollama.com) installed and running
+
+---
+
+## Installation
+
+### pip
+
+```bash
+pip install olmon
+```
+
+### curl (Linux / macOS)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/glemiu6/olmon/master/scripts/install.sh | sh
+```
+
+### From source
+
+```bash
+git clone https://github.com/glemiu6/olmon.git
+cd olmon
+uv pip install -e .
+```
+### Windows
+
+Native Windows binary is not currently supported.
+Use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) and follow the Linux installation instructions.
+---
+
+## Usage
+
+```bash
+olmon status               # quick health check
+olmon models               # list all installed models
+olmon models --sort size   # sort by size
+olmon models --filter llama  # filter by name or family
+olmon inspect llama3:latest  # full details on a model
+olmon ps                   # show currently running models
+olmon watch                # live auto-refreshing dashboard
+olmon watch --interval 5   # refresh every 5 seconds
+```
+
+### Global flags
+
+```bash
+olmon --host http://192.168.1.10:11434 status   # connect to remote Ollama
+olmon --version                                  # print version
+```
+
+---
+
+## Status Indicators
+
+| Indicator | Meaning |
+|-----------|---------|
+| 🟢 Green  | Models are loaded and running |
+| 🔵 Blue   | Ollama is idle, no models loaded |
+| 🔴 Red    | Ollama is offline or unreachable |
+
+---
+
+## Configuration
+
+```bash
+olmon init          # create default config file
+olmon config show   # view current config
+```
+
+Config is stored at `~/.config/olmon/config.json`:
+
+```json
+{
+  "host": "http://localhost:11434",
+  "interval": 2,
+  "no_color": false,
+  "default_sort": "name"
+}
+```
+
+---
+
+## Update & Uninstall
+
+```bash
+olmon update      # update to latest version
+olmon uninstall   # remove olmon and config
+```
+
+---
+
+## Why olmon?
+
+Most Ollama monitoring tools are GUI or system tray apps. `olmon` is built for:
+
+- **Headless Linux servers** — no GUI required
+- **Remote monitoring** — works over SSH
+- **Shell scripting** — pipe-friendly with `--json` flag and exit codes
+- **DevOps workflows** — integrate into scripts and cron jobs
+
+---
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) for the full plan.
+
+---
+
+## Contributing
+
+Contributions are welcome. Feel free to open an issue or submit a pull request.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.
+
+---
+
+Made with ❤️ by [Vlad Digori](https://github.com/glemiu6)

olmon-0.1.0/olmon.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+olmon/__init__.py
+olmon/__main__.py
+olmon/client.py
+olmon/config.py
+olmon/display.py
+olmon/main.py
+olmon.egg-info/PKG-INFO
+olmon.egg-info/SOURCES.txt
+olmon.egg-info/dependency_links.txt
+olmon.egg-info/entry_points.txt
+olmon.egg-info/requires.txt
+olmon.egg-info/top_level.txt
+olmon/commands/__init__.py
+olmon/commands/init.py
+olmon/commands/models.py
+olmon/commands/ps.py
+olmon/commands/status.py
+olmon/commands/uninstall.py
+olmon/commands/update.py
+olmon/commands/watch.py

olmon-0.1.0/olmon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

olmon-0.1.0/olmon.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+olmon = olmon.main:app

olmon-0.1.0/olmon.egg-info/requires.txt

@@ -0,0 +1,3 @@
+mypy>=2.1.0
+platformdirs>=4.10.0
+rich>=15.0.0

olmon-0.1.0/olmon.egg-info/top_level.txt

@@ -0,0 +1 @@
+olmon

olmon-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "olmon"
+version = "0.1.0"
+description = "A lightweight CLI to monitor Ollama models and usage"
+readme = "README.md"
+requires-python = ">=3.13"
+license = { text = "MIT" }
+authors = [
+    { name = "Vlad Digori", email = "digorivlad59@gmail.com" }
+]
+keywords = ["ollama", "monitor", "cli", "llm", "devops", "developer-tools"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "mypy>=2.1.0",
+    "platformdirs>=4.10.0",
+    "rich>=15.0.0",
+]
+
+[project.scripts]
+olmon = "olmon.main:app"
+
+[project.urls]
+Homepage = "https://github.com/glemiu6/olmon"
+Repository = "https://github.com/glemiu6/olmon"
+"Bug Tracker" = "https://github.com/glemiu6/olmon/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "build>=1.4.4",
+    "twine>=6.2.0",
+    "pyinstaller>=6.0.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.4.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = []

olmon-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+