notebook-llm-cli 0.1.1__tar.gz → 0.2.0__tar.gz

{notebook_llm_cli-0.1.1/notebook_llm_cli.egg-info → notebook_llm_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notebook-llm-cli
-Version: 0.1.1
+Version: 0.2.0
 Summary: Interactive CLI to run Ollama LLMs on Kaggle/Colab GPUs: GPU detection, fit and tokens/sec estimates, library search, public tunnel.
 Author-email: Shashan Lumbhani <lumbhanishashan1510@gmail.com>
 License: MIT
@@ -45,17 +45,29 @@ Note: `!notebook-llm` cannot take keyboard input in Kaggle, so use `notebook_llm
 1. Quick start - installs everything, picks the best model that fits, loads it, opens the tunnel
 2. Search Ollama library - live search of ollama.com/search (paged with `m`, filters like `/tools /vision /thinking /embedding /newest`, or paste `model:tag` / a library URL). Cloud-only models are hidden because they don't run on your GPU (`/cloud` shows them). Pick a model to see FIT verdict and ~tok/s for every size, then pull/load
 3. Recommended models for my GPU
-4. Installed models - load / unload / benchmark (real tok/s) / delete
-5. Tunnel - open, show link, Continue config, close, new link
-6. Server - start / stop / restart / logs / GPU report
-7. Settings - context length, KV cache type, flash attention, keep-alive (saved)
-8. Benchmark the active model
+4. **Quant picker** - compare every quantization (q2 / q4_K_M / q5 / q8 / fp16 ...) of one model size: exact size, fit, ~tok/s, quality, and a suggested pick. Also reachable from any list by typing `q3` (= quants of row 3)
+5. Installed models - load / unload / benchmark (real tok/s) / delete
+6. **Connect your tools** - ready-to-paste settings for Continue, Cline, Aider, Open WebUI, Claude Code, Cursor, Antigravity IDE and Python/curl, filled in with your tunnel link, model and context length. Save them all to a file with `s`
+7. Tunnel - open, show link, close, new link
+8. Server - start / stop / restart / logs / GPU report
+9. Settings - context length, KV cache type, flash attention, keep-alive, models folder (saved)
+10. Benchmark the active model
+
+### Disk-space check
+Before every download the tool compares the model size (+5% +1 GB) with free space in the models folder. If it won't fit you can delete models on the spot, pick a smaller quant, or continue anyway. The models folder is chosen automatically (the disk with the most free space, e.g. `/kaggle/temp`) and shown in the header; change it in Settings.
+
+### Tool notes
+- Cursor sends requests from its own servers, so it needs the public tunnel link (that's what this tool gives you).
+- Claude Code uses Ollama's Anthropic-compatible API (`ANTHROPIC_BASE_URL`); it needs a tool-capable model and a large context.
+- Antigravity IDE has no custom-model setting, so use the Continue/Cline extension inside it.
 
 ## Non-interactive
 ```
 notebook-llm gpus                    # hardware + recommended table
 notebook-llm search coder
 notebook-llm check llama3.1:70b --ctx 8192
+notebook-llm quants qwen2.5-coder:7b # compare quantizations
+notebook-llm connect cursor          # or: continue cline aider openwebui claude-code antigravity python (none = all)
 notebook-llm quickstart --model auto
 notebook-llm status | stop
 ```
@@ -66,6 +78,7 @@ from notebook_llm import NotebookLLM
 llm = NotebookLLM()
 url = llm.quickstart()               # install -> serve -> pull -> load -> tunnel
 llm.chat("hello"); llm.benchmark(); llm.close_tunnel(); llm.stop_server()
+print(llm.connect("cursor"))        # settings text for a tool; llm.connect() = all tools
 ```
 
 ## How the estimates work

{notebook_llm_cli-0.1.1 → notebook_llm_cli-0.2.0}/README.md

@@ -23,17 +23,29 @@ Note: `!notebook-llm` cannot take keyboard input in Kaggle, so use `notebook_llm
 1. Quick start - installs everything, picks the best model that fits, loads it, opens the tunnel
 2. Search Ollama library - live search of ollama.com/search (paged with `m`, filters like `/tools /vision /thinking /embedding /newest`, or paste `model:tag` / a library URL). Cloud-only models are hidden because they don't run on your GPU (`/cloud` shows them). Pick a model to see FIT verdict and ~tok/s for every size, then pull/load
 3. Recommended models for my GPU
-4. Installed models - load / unload / benchmark (real tok/s) / delete
-5. Tunnel - open, show link, Continue config, close, new link
-6. Server - start / stop / restart / logs / GPU report
-7. Settings - context length, KV cache type, flash attention, keep-alive (saved)
-8. Benchmark the active model
+4. **Quant picker** - compare every quantization (q2 / q4_K_M / q5 / q8 / fp16 ...) of one model size: exact size, fit, ~tok/s, quality, and a suggested pick. Also reachable from any list by typing `q3` (= quants of row 3)
+5. Installed models - load / unload / benchmark (real tok/s) / delete
+6. **Connect your tools** - ready-to-paste settings for Continue, Cline, Aider, Open WebUI, Claude Code, Cursor, Antigravity IDE and Python/curl, filled in with your tunnel link, model and context length. Save them all to a file with `s`
+7. Tunnel - open, show link, close, new link
+8. Server - start / stop / restart / logs / GPU report
+9. Settings - context length, KV cache type, flash attention, keep-alive, models folder (saved)
+10. Benchmark the active model
+
+### Disk-space check
+Before every download the tool compares the model size (+5% +1 GB) with free space in the models folder. If it won't fit you can delete models on the spot, pick a smaller quant, or continue anyway. The models folder is chosen automatically (the disk with the most free space, e.g. `/kaggle/temp`) and shown in the header; change it in Settings.
+
+### Tool notes
+- Cursor sends requests from its own servers, so it needs the public tunnel link (that's what this tool gives you).
+- Claude Code uses Ollama's Anthropic-compatible API (`ANTHROPIC_BASE_URL`); it needs a tool-capable model and a large context.
+- Antigravity IDE has no custom-model setting, so use the Continue/Cline extension inside it.
 
 ## Non-interactive
 ```
 notebook-llm gpus                    # hardware + recommended table
 notebook-llm search coder
 notebook-llm check llama3.1:70b --ctx 8192
+notebook-llm quants qwen2.5-coder:7b # compare quantizations
+notebook-llm connect cursor          # or: continue cline aider openwebui claude-code antigravity python (none = all)
 notebook-llm quickstart --model auto
 notebook-llm status | stop
 ```
@@ -44,6 +56,7 @@ from notebook_llm import NotebookLLM
 llm = NotebookLLM()
 url = llm.quickstart()               # install -> serve -> pull -> load -> tunnel
 llm.chat("hello"); llm.benchmark(); llm.close_tunnel(); llm.stop_server()
+print(llm.connect("cursor"))        # settings text for a tool; llm.connect() = all tools
 ```
 
 ## How the estimates work

{notebook_llm_cli-0.1.1 → notebook_llm_cli-0.2.0}/notebook_llm/__init__.py

@@ -5,8 +5,10 @@ from .library import LibModel, Candidate, search, make_candidate
 from .manager import NotebookLLM, Settings
 from .cli import run, main
 from .env import is_kaggle
+from .disk import DiskSpaceError
+from .integrations import render as render_config, TOOLS
 
 __all__ = ["NotebookLLM", "Settings", "run", "main", "GPU", "GPUInfo", "Hardware",
            "detect_gpus", "detect_hardware", "Estimate", "estimate", "LibModel",
-           "Candidate", "search", "make_candidate", "is_kaggle"]
-__version__ = "0.1.0"
+           "Candidate", "search", "make_candidate", "is_kaggle", "DiskSpaceError", "render_config", "TOOLS"]
+__version__ = "0.2.0"

{notebook_llm_cli-0.1.1 → notebook_llm_cli-0.2.0}/notebook_llm/cli.py

@@ -1,11 +1,13 @@
 """Interactive CLI. Run `notebook-llm` (terminal) or `notebook_llm.run()` (notebook cell)."""
 import argparse
-import sys
+import os
+import re
 
-from . import library, ui
+from . import disk, library, ui
 from .env import is_kaggle
+from .integrations import TOOLS
 from .manager import NotebookLLM
-from .ui import c, ask, confirm, pick, table, title
+from .ui import ask, c, confirm, pick, table, title
 
 
 # ---------- rendering helpers ---------------------------------------
@@ -18,7 +20,6 @@ def speed_cell(est) -> str:
 
 
 def show_candidates(cands, llm):
-    ctx = cands[0].est.context if cands else "-"
     ui.info(f"Hardware: {llm.hw.summary()}")
     ui.info("NEEDS = weights + KV cache (auto context) + overhead. tok/s is an estimate (+-30%).")
     rows = []
@@ -49,6 +50,7 @@ def header(llm: NotebookLLM):
         print(f"  VRAM in use: {llm.hw.gpu.used_vram_gb} / {llm.hw.gpu.total_vram_gb} GB")
     elif is_kaggle():
         ui.warn("No GPU. In Kaggle: Settings > Accelerator > GPU T4 x2, then restart.")
+    print(f"  Disk   : {disk.free_gb(llm.models_dir):.0f} GB free  ({llm.models_dir})")
     up = llm.server.is_running()
     print(f"  Server : {c('running', 'green') if up else c('stopped', 'red')}")
     if up:
@@ -59,7 +61,7 @@ def header(llm: NotebookLLM):
         except Exception:
             pass
     print(f"  Model  : {llm.settings.model or '(none selected)'}")
-    print(f"  Tunnel : {c(llm.url, 'bold', 'green') if llm.url else c('closed', 'gray')}")
+    print(f"  Tunnel : {c(llm.url, 'bold', 'green') if llm.url else 'closed'}")
 
 
 # ---------- flows ----------------------------------------------------
@@ -75,6 +77,24 @@ def ensure_server(llm, model=None) -> bool:
         return False
 
 
+def ensure_disk(llm, cd) -> bool:
+    """Check free space before a download. Returns True if OK to proceed."""
+    chk = llm.space_for(cd.size_gb)
+    if chk.ok:
+        ui.info(f"Disk check: {chk.free_gb:.0f} GB free, need ~{chk.needed_gb:.0f} GB. OK.")
+        return True
+    ui.err(f"Not enough disk space in {chk.path}: {chk.free_gb:.1f} GB free, need ~{chk.needed_gb:.1f} GB.")
+    print("  Ways to fix it: delete models you don't need, pick a smaller size or quantization "
+          "(type qN in the list), or change the models folder in Settings.")
+    if llm.installed() and confirm("Open 'Installed models' to free space now?"):
+        flow_installed(llm)
+        chk = llm.space_for(cd.size_gb)
+        if chk.ok:
+            ui.ok(f"Now {chk.free_gb:.0f} GB free. Continuing.")
+            return True
+    return confirm("Try the download anyway?", False)
+
+
 def after_load(llm):
     if not llm.url and confirm("Open a public tunnel now?"):
         flow_open_tunnel(llm)
@@ -94,8 +114,10 @@ def model_actions(llm, cd):
         return
     try:
         if not llm.client.has_model(cd.ref):
+            if not ensure_disk(llm, cd):
+                return
             print(f"  Pulling {cd.ref} ({cd.size_gb:.1f} GB)...")
-            llm.pull(cd.ref)
+            llm.pull(cd.ref, cd.size_gb, force=True)  # already checked above
         if ch == "1":
             print("  Loading into VRAM...")
             llm.load(cd.ref)
@@ -103,6 +125,8 @@ def model_actions(llm, cd):
             after_load(llm)
     except Exception as e:
         ui.err(str(e))
+        if "space" in str(e).lower():
+            ui.warn("The disk filled up during the download. Delete a model or pick a smaller one.")
 
 
 def _result_rows(res, offset=0):
@@ -165,30 +189,99 @@ def flow_search(llm):
         return
 
 
+def _select_from_candidates(llm, cands, extra_hint=""):
+    """Number = select, qN = quant picker for row N. Returns after handling."""
+    v = ask(f"Choose a number, qN to compare quantizations of row N{extra_hint}. Enter = back")
+    if not v or v in ("b", "q"):
+        return "back"
+    m = re.fullmatch(r"q\s*(\d+)", v.lower())
+    if m and 1 <= int(m.group(1)) <= len(cands):
+        flow_quants(llm, cands[int(m.group(1)) - 1].ref)
+        return "again"
+    if v.isdigit() and 1 <= int(v) <= len(cands):
+        model_actions(llm, cands[int(v) - 1])
+        return "back"
+    return v  # custom tag
+
+
 def flow_pick_tag(llm, m):
     while True:
         print(f"\n  Checking sizes for {m.name} (registry lookup)...")
         cands = library.candidates_for(m, llm.hw, llm.settings.context, llm.settings.kv_cache)
         title(m.name)
         show_candidates(cands, llm)
-        print("  Type a number, or a custom tag (e.g. 14b-instruct-q8_0). Enter = back.")
-        v = ask("Choose")
-        if not v or v in ("b", "q"):
+        r = _select_from_candidates(llm, cands, " or type a custom tag")
+        if r == "back":
             return
-        if v.isdigit() and 1 <= int(v) <= len(cands):
-            return model_actions(llm, cands[int(v) - 1])
-        model_actions(llm, library.make_candidate(f"{m.name}:{v}", llm.hw, llm.settings.context, llm.settings.kv_cache))
+        if r == "again":
+            continue
+        model_actions(llm, library.make_candidate(f"{m.name}:{r}", llm.hw, llm.settings.context, llm.settings.kv_cache))
         return
 
 
 def flow_recommended(llm):
-    cands = llm.recommended()
-    cands = [x for x in cands if x.est.verdict != "no"] or cands
-    title("Recommended for your hardware")
-    show_candidates(cands, llm)
-    i = pick("Select model", len(cands))
+    while True:
+        cands = [x for x in llm.recommended() if x.est.verdict != "no"] or llm.recommended()
+        title("Recommended for your hardware")
+        show_candidates(cands, llm)
+        r = _select_from_candidates(llm, cands)
+        if r == "again":
+            continue
+        if r not in ("back",):
+            continue
+        return
+
+
+def flow_quants(llm, ref=None):
+    """Compare every quantization (q4/q5/q8/fp16...) of one model size: fit, speed, quality."""
+    if not ref:
+        ref = ask("Model and size, e.g. qwen2.5-coder:7b (or just a name like qwen2.5-coder)")
+        if not ref or ref in ("q", "b"):
+            return
+    name, _, tag = ref.partition(":")
+    if not library.size_of(tag):
+        print(f"  Looking up sizes for {name}...")
+        try:
+            lm = next((x for x in library.search(name) if x.name == name), None)
+        except library.LibraryError as e:
+            ui.err(str(e))
+            return
+        sizes = [s for s in (lm.sizes if lm else []) if "cloud" not in s]
+        if not sizes:
+            ui.warn(f"No sized tags found for '{name}'. Use the form name:size, e.g. qwen2.5-coder:7b")
+            return
+        for i, s in enumerate(sizes, 1):
+            print(f"  {i}) {name}:{s}")
+        i = pick("Which size", len(sizes))
+        if i is None:
+            return
+        tag = sizes[i]
+    size_tag = library.size_of(tag)
+    print(f"  Fetching quantizations of {name}:{size_tag} (registry lookups)...")
+    try:
+        rows = library.quant_candidates(name, size_tag, llm.hw, llm.settings.context, llm.settings.kv_cache)
+    except library.LibraryError as e:
+        ui.err(str(e))
+        return
+    best = library.suggest_quant(rows)
+    title(f"Quantizations of {name}:{size_tag}")
+    ui.info(f"Hardware: {llm.hw.summary()}")
+    out = []
+    for i, r in enumerate(rows, 1):
+        cd = r.cand
+        mark = c("<- suggested", "green") if best is r else ""
+        out.append((i, r.tag, r.variant, r.quant or "-", library.quality_of(r.quant),
+                    f"{cd.size_gb:.1f} GB" + ("" if cd.exact else "~"), f"{cd.est.needed_gb:.1f} GB",
+                    fit_cell(cd.est), speed_cell(cd.est), mark))
+    table(["#", "TAG", "VARIANT", "QUANT", "QUALITY", "SIZE", "NEEDS", "FIT", "TOK/S", ""], out, right_cols=(0, 5, 6, 8))
+    if best:
+        ui.info(f"Suggested = best quality that fits your GPU and stays at 15+ tok/s: {name}:{best.tag}")
+    else:
+        ui.warn("Nothing fits comfortably. Try a smaller size (low-bit quants lose quality).")
+    ui.info("Lower quant = smaller and faster but less accurate. q4_K_M is the usual sweet spot; q8 is near-lossless.")
+    i = pick("Select which", len(rows))
     if i is not None:
-        model_actions(llm, library.make_candidate(cands[i].ref, llm.hw, llm.settings.context, llm.settings.kv_cache))
+        model_actions(llm, rows[i].cand)
 
 
 def flow_installed(llm):
@@ -208,6 +301,7 @@ def flow_installed(llm):
         rows.append((i, m["name"], f"{cd.size_gb:.1f} GB", fit_cell(cd.est), speed_cell(cd.est), mark, active))
     title("Installed models")
     table(["#", "MODEL", "SIZE", "FIT", "TOK/S", "STATE", ""], rows, right_cols=(0, 2, 4))
+    ui.info(f"Disk free: {disk.free_gb(llm.models_dir):.0f} GB in {llm.models_dir}")
     i = pick("Manage which", len(inst))
     if i is None:
         return
@@ -226,7 +320,7 @@ def flow_installed(llm):
             flow_benchmark(llm, name)
         elif ch == "4" and confirm(f"Delete {name}?", False):
             llm.delete(name)
-            ui.ok("Deleted.")
+            ui.ok(f"Deleted. Disk free now: {disk.free_gb(llm.models_dir):.0f} GB")
     except Exception as e:
         ui.err(str(e))
 
@@ -253,28 +347,64 @@ def flow_benchmark(llm, name=None):
             ui.warn("Model is partly on CPU. Try a smaller model/quant or lower context in Settings.")
 
 
-def flow_open_tunnel(llm):
+def open_tunnel_quiet(llm):
     if not ensure_server(llm):
-        return
+        return None
     try:
-        url = llm.open_tunnel()
+        return llm.open_tunnel()
     except Exception as e:
         ui.err(str(e))
+        return None
+
+
+def flow_open_tunnel(llm):
+    url = open_tunnel_quiet(llm)
+    if not url:
         return
     print("\n  " + c(url, "bold", "green"))
     ui.warn("Anyone with this link can use your GPU. It changes every time you reopen the tunnel.")
-    if llm.settings.model:
-        print("\n  Paste into Continue config.yaml:\n")
-        print(llm.continue_config())
+    ui.info("Next: menu 'Connect your tools' prints settings for Cline, Aider, Cursor, Claude Code and more.")
+
+
+def flow_connect(llm):
+    """Print ready-to-paste settings for coding tools."""
+    if not llm.settings.model:
+        ui.warn("Load a model first (Quick start / Recommended / Search).")
+        return
+    if not llm.url:
+        if not confirm("These tools need the public tunnel link. Open it now?"):
+            return
+        if not open_tunnel_quiet(llm):
+            return
+    while True:
+        title(f"Connect your tools  ({llm.settings.model})")
+        print(f"  Link: {c(llm.url, 'bold', 'green')}\n")
+        for i, (_, label, _) in enumerate(TOOLS, 1):
+            print(f"  {c(i, 'cyan')}) {label}")
+        print(f"  {c('a', 'cyan')}) Show all     {c('s', 'cyan')}) Save all to a file")
+        v = ask("Choose (Enter = back)").lower()
+        if not v or v in ("b", "q"):
+            return
+        if v == "a":
+            print("\n" + llm.connect())
+        elif v == "s":
+            base = "/kaggle/working" if os.path.isdir("/kaggle/working") else os.getcwd()
+            path = os.path.join(base, "notebook_llm_connect.txt")
+            with open(path, "w") as f:
+                f.write(llm.connect())
+            ui.ok(f"Saved to {path}")
+        elif v.isdigit() and 1 <= int(v) <= len(TOOLS):
+            print("\n" + llm.connect(TOOLS[int(v) - 1][0]))
+        print()
 
 
 def flow_tunnel(llm):
     if not llm.url:
         return flow_open_tunnel(llm)
-    print(f"\n  Tunnel: {c(llm.url, 'bold', 'green')}\n  1) Show Continue config\n  2) Close tunnel\n  3) New tunnel (new link)\n  Enter) back")
+    print(f"\n  Tunnel: {c(llm.url, 'bold', 'green')}\n  1) Connect your tools (Cline, Aider, Cursor...)\n  2) Close tunnel\n  3) New tunnel (new link)\n  Enter) back")
     ch = ask("Choose")
     if ch == "1":
-        print("\n" + llm.continue_config())
+        flow_connect(llm)
     elif ch == "2":
         llm.close_tunnel()
         ui.ok("Tunnel closed.")
@@ -305,7 +435,8 @@ def flow_server(llm):
 def flow_settings(llm):
     s = llm.settings
     print(f"\n  1) Context length : {s.context or 'auto'}\n  2) KV cache type  : {s.kv_cache}   (f16 | q8_0 | q4_0)\n"
-          f"  3) Flash attention: {s.flash_attention}\n  4) Keep-alive     : {s.keep_alive}   (-1 = forever, or e.g. 30m)\n  Enter) back")
+          f"  3) Flash attention: {s.flash_attention}\n  4) Keep-alive     : {s.keep_alive}   (-1 = forever, or e.g. 30m)\n"
+          f"  5) Models folder  : {llm.models_dir}  ({disk.free_gb(llm.models_dir):.0f} GB free)\n  Enter) back")
     ch = ask("Change which")
     if ch == "1":
         v = ask("Context tokens (number, or 'auto')", "auto")
@@ -317,13 +448,20 @@ def flow_settings(llm):
         s.flash_attention = confirm("Enable flash attention?", s.flash_attention)
     elif ch == "4":
         s.keep_alive = ask("Keep-alive", s.keep_alive)
+    elif ch == "5":
+        ui.warn("Models already downloaded stay in the old folder and will not be visible from the new one.")
+        for i, d in enumerate(disk.candidate_dirs(), 1):
+            print(f"  {i}) {d}  ({disk.free_gb(d):.0f} GB free)")
+        v = ask("Folder path or number", llm.models_dir)
+        dirs = disk.candidate_dirs()
+        s.models_dir = dirs[int(v) - 1] if v.isdigit() and 1 <= int(v) <= len(dirs) else v
     else:
         return
     s.save()
     ui.ok("Saved.")
     if llm.server.is_running() and confirm("Restart server to apply now?"):
         llm.restart_server()
-        if s.model:
+        if s.model and llm.client.has_model(s.model):
             llm.load(s.model)
 
 
@@ -338,18 +476,21 @@ def flow_quickstart(llm):
         ui.err(str(e))
         return
     ui.ok(f"Ready: {llm.settings.model}")
-    print("\n  " + c(url, "bold", "green"))
-    print("\n" + llm.continue_config())
+    print("\n  " + c(url or "(no tunnel)", "bold", "green"))
+    if url and confirm("Show setup for your coding tools now?"):
+        flow_connect(llm)
 
 
 MENU = [
     ("Quick start (auto: install, model, tunnel)", flow_quickstart),
     ("Search Ollama library", flow_search),
     ("Recommended models for my GPU", flow_recommended),
+    ("Quant picker (compare q4 / q5 / q8 / fp16)", flow_quants),
     ("Installed models (load / benchmark / delete)", flow_installed),
+    ("Connect your tools (Cline, Aider, Cursor, Claude Code...)", flow_connect),
     ("Tunnel (open / get link / close)", flow_tunnel),
     ("Server (start / stop / logs)", flow_server),
-    ("Settings (context, KV cache, keep-alive)", flow_settings),
+    ("Settings (context, KV cache, keep-alive, folder)", flow_settings),
     ("Benchmark active model", flow_benchmark),
 ]
 
@@ -385,6 +526,10 @@ def main(argv=None) -> None:
     k = sub.add_parser("check", help="will MODEL fit? estimated tok/s")
     k.add_argument("model")
     k.add_argument("--ctx", type=int)
+    qn = sub.add_parser("quants", help="compare quantizations, e.g. qwen2.5-coder:7b")
+    qn.add_argument("model")
+    cn = sub.add_parser("connect", help="print settings for a tool (continue, cline, aider, openwebui, claude-code, cursor, antigravity, python)")
+    cn.add_argument("tool", nargs="?")
     q = sub.add_parser("quickstart", help="install, start, pull best model, open tunnel")
     q.add_argument("--model", default="auto")
     q.add_argument("--no-tunnel", action="store_true")
@@ -392,7 +537,6 @@ def main(argv=None) -> None:
     sub.add_parser("stop", help="stop tunnel and server")
     a = p.parse_args(argv)
     if a.no_color:
-        import os
         os.environ["NO_COLOR"] = "1"
 
     if a.cmd is None:
@@ -403,14 +547,25 @@ def main(argv=None) -> None:
         show_candidates(llm.recommended(), llm)
     elif a.cmd == "search":
         for m in library.search(a.query)[:20]:
-            print(f"{m.name:28} {m.pulls:>8}  {', '.join(m.sizes)}")
+            print(f"{m.name:28} {m.pulls:>8}  {', '.join(m.sizes)}{'  [cloud]' if m.cloud else ''}")
     elif a.cmd == "check":
-        cd = library.make_candidate(a.model, llm.hw, a.ctx, llm.settings.kv_cache)
-        show_estimate_detail(cd)
+        show_estimate_detail(library.make_candidate(a.model, llm.hw, a.ctx, llm.settings.kv_cache))
+    elif a.cmd == "quants":
+        name, _, tag = a.model.partition(":")
+        rows = library.quant_candidates(name, library.size_of(tag) or tag, llm.hw, llm.settings.context, llm.settings.kv_cache)
+        best = library.suggest_quant(rows)
+        out = [(r.tag, library.quality_of(r.quant), f"{r.cand.size_gb:.1f} GB", f"{r.cand.est.needed_gb:.1f} GB",
+                fit_cell(r.cand.est), speed_cell(r.cand.est), "<- suggested" if r is best else "") for r in rows]
+        table(["TAG", "QUALITY", "SIZE", "NEEDS", "FIT", "TOK/S", ""], out, right_cols=(2, 3, 5))
+    elif a.cmd == "connect":
+        try:
+            print(llm.connect(a.tool))
+        except KeyError as e:
+            raise SystemExit(str(e).strip("\"'"))
     elif a.cmd == "quickstart":
         url = llm.quickstart(a.model, tunnel=not a.no_tunnel)
         print(url or "")
-        print(llm.continue_config())
+        print(llm.connect())
     elif a.cmd == "status":
         print(f"server={llm.server.is_running()} model={llm.settings.model} tunnel={llm.url}")
     elif a.cmd == "stop":

notebook_llm_cli-0.2.0/notebook_llm/disk.py

@@ -0,0 +1,73 @@
+"""Disk-space checks for model downloads."""
+import os
+import shutil
+from dataclasses import dataclass
+
+
+class DiskSpaceError(RuntimeError):
+    pass
+
+
+@dataclass
+class SpaceCheck:
+    ok: bool
+    free_gb: float
+    needed_gb: float
+    path: str
+
+
+def default_models_dir() -> str:
+    return os.environ.get("OLLAMA_MODELS") or os.path.expanduser("~/.ollama/models")
+
+
+def _existing_parent(path: str) -> str:
+    p = os.path.abspath(path)
+    while not os.path.exists(p):
+        parent = os.path.dirname(p)
+        if parent == p:
+            break
+        p = parent
+    return p
+
+
+def free_gb(path: str) -> float:
+    return shutil.disk_usage(_existing_parent(path)).free / 1024 ** 3
+
+
+def dir_size_gb(path: str) -> float:
+    total = 0
+    for root, _, files in os.walk(path):
+        for f in files:
+            try:
+                total += os.path.getsize(os.path.join(root, f))
+            except OSError:
+                pass
+    return total / 1024 ** 3
+
+
+def has_models(path: str) -> bool:
+    blobs = os.path.join(path, "blobs")
+    return os.path.isdir(blobs) and any(True for _ in os.scandir(blobs))
+
+
+def candidate_dirs():
+    out = [default_models_dir()]
+    for base in ("/kaggle/temp", "/tmp"):
+        if os.path.isdir(base):
+            out.append(os.path.join(base, "ollama_models"))
+    return out
+
+
+def pick_models_dir() -> str:
+    """Keep the default if it already holds models; otherwise use the disk with the most free space."""
+    default = default_models_dir()
+    if has_models(default):
+        return default
+    best = max(candidate_dirs(), key=free_gb)
+    return best if free_gb(best) > free_gb(default) + 2 else default
+
+
+def check_space(size_gb: float, path: str) -> SpaceCheck:
+    needed = size_gb * 1.05 + 1.0     # download + 5% + 1 GB headroom
+    free = free_gb(path)
+    return SpaceCheck(free >= needed, free, needed, path)