hubble-cli 4.0.0__py3-none-any.whl

hubble/web.py

@@ -0,0 +1,279 @@
+"""Web tools: web_search (DuckDuckGo by default, Brave/Tavily with an API key) and web_fetch.
+
+web_fetch refuses loopback/private/link-local addresses, so the model cannot probe the
+user's local network or cloud metadata endpoints.
+"""
+
+import html
+import ipaddress
+import os
+import re
+import socket
+from html.parser import HTMLParser
+from typing import Any, Dict, List, Optional
+from urllib.parse import parse_qs, unquote, urlparse
+
+import httpx
+
+from hubble.tools import Tool, ToolContext, ToolError
+
+USER_AGENT = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
+              "Chrome/124.0 Safari/537.36 Hubble-CLI")
+TIMEOUT = httpx.Timeout(connect=10.0, read=25.0, write=10.0, pool=10.0)
+MAX_DOWNLOAD = 3_000_000
+MAX_RESULTS = 10
+
+
+# ----- search backends ------------------------------------------------------
+
+def _strip_tags(s: str) -> str:
+    return html.unescape(re.sub(r"<[^>]+>", "", s)).strip()
+
+
+def search_duckduckgo(query: str, limit: int) -> List[Dict[str, str]]:
+    resp = httpx.post("https://html.duckduckgo.com/html/", data={"q": query},
+                      headers={"User-Agent": USER_AGENT}, timeout=TIMEOUT, follow_redirects=True)
+    if resp.status_code != 200:
+        raise ToolError(f"DuckDuckGo returned HTTP {resp.status_code}")
+    page = resp.text
+    if "anomaly" in page.lower() and "result__a" not in page:
+        raise ToolError("DuckDuckGo asked for a captcha; set a Brave or Tavily API key for reliable search")
+    results = []
+    blocks = re.split(r'<div[^>]+class="[^"]*result(?:s_links)?[^"]*"', page)
+    for block in blocks:
+        link = re.search(r'<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>(.*?)</a>', block, re.S)
+        if not link:
+            continue
+        href = html.unescape(link.group(1))
+        if "duckduckgo.com/l/" in href:  # redirect wrapper: real URL is in uddg=
+            href = unquote(parse_qs(urlparse(href).query).get("uddg", [href])[0])
+        if href.startswith("//"):
+            href = "https:" + href
+        if "duckduckgo.com/y.js" in href:  # ads
+            continue
+        snippet = re.search(r'class="result__snippet"[^>]*>(.*?)</a>', block, re.S)
+        results.append({"title": _strip_tags(link.group(2)), "url": href,
+                        "snippet": _strip_tags(snippet.group(1)) if snippet else ""})
+        if len(results) >= limit:
+            break
+    return results
+
+
+def search_brave(query: str, limit: int, key: str) -> List[Dict[str, str]]:
+    resp = httpx.get("https://api.search.brave.com/res/v1/web/search", params={"q": query, "count": limit},
+                     headers={"X-Subscription-Token": key, "Accept": "application/json"}, timeout=TIMEOUT)
+    if resp.status_code != 200:
+        raise ToolError(f"Brave Search returned HTTP {resp.status_code}")
+    items = (resp.json().get("web") or {}).get("results") or []
+    return [{"title": i.get("title", ""), "url": i.get("url", ""), "snippet": _strip_tags(i.get("description", ""))}
+            for i in items[:limit]]
+
+
+def search_tavily(query: str, limit: int, key: str) -> List[Dict[str, str]]:
+    resp = httpx.post("https://api.tavily.com/search", json={"api_key": key, "query": query, "max_results": limit},
+                      timeout=TIMEOUT)
+    if resp.status_code != 200:
+        raise ToolError(f"Tavily returned HTTP {resp.status_code}")
+    return [{"title": i.get("title", ""), "url": i.get("url", ""), "snippet": (i.get("content") or "")[:300]}
+            for i in (resp.json().get("results") or [])[:limit]]
+
+
+def web_search(query: str, limit: int = 8, config: Optional[Dict[str, Any]] = None) -> List[Dict[str, str]]:
+    cfg = config or {}
+    brave = cfg.get("brave_api_key") or os.environ.get("BRAVE_API_KEY")
+    tavily = cfg.get("tavily_api_key") or os.environ.get("TAVILY_API_KEY")
+    engine = (cfg.get("engine") or "auto").lower()
+    if engine in ("brave", "auto") and brave:
+        return search_brave(query, limit, brave)
+    if engine in ("tavily", "auto") and tavily:
+        return search_tavily(query, limit, tavily)
+    try:
+        return search_duckduckgo(query, limit)
+    except httpx.HTTPError as e:
+        raise ToolError(f"search failed: {type(e).__name__}: {e}")
+
+
+# ----- fetch -----------------------------------------------------------------
+
+class _TextExtractor(HTMLParser):
+    SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "form", "iframe", "template", "head"}
+    BLOCK = {"p", "div", "section", "article", "main", "br", "li", "ul", "ol", "table", "tr", "pre",
+             "blockquote", "h1", "h2", "h3", "h4", "h5", "h6", "header", "aside", "dd", "dt"}
+
+    def __init__(self, base: str):
+        super().__init__(convert_charrefs=True)
+        self.base = base
+        self.out: List[str] = []
+        self.skip = 0
+        self.title = ""
+        self._in_title = False
+        self._href: Optional[str] = None
+        self._link_start = 0
+        self._pre = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag == "title":
+            self._in_title = True
+        if tag in self.SKIP:
+            self.skip += 1
+            return
+        if self.skip:
+            return
+        if tag in ("h1", "h2", "h3", "h4"):
+            self.out.append("\n\n" + "#" * int(tag[1]) + " ")
+        elif tag == "li":
+            self.out.append("\n- ")
+        elif tag == "pre":
+            self._pre += 1
+            self.out.append("\n```\n")
+        elif tag in self.BLOCK:
+            self.out.append("\n")
+        elif tag == "a":
+            href = dict(attrs).get("href") or ""
+            self._href = href if href.startswith("http") else None
+            self._link_start = len(self.out)
+
+    def handle_endtag(self, tag):
+        if tag == "title":
+            self._in_title = False
+        if tag in self.SKIP:
+            self.skip = max(0, self.skip - 1)
+            return
+        if self.skip:
+            return
+        if tag == "pre":
+            self._pre = max(0, self._pre - 1)
+            self.out.append("\n```\n")
+        elif tag == "a" and self._href:
+            if "".join(self.out[self._link_start:]).strip():  # skip icon/image-only links
+                self.out.append(f" ({self._href})")
+            self._href = None
+        elif tag in self.BLOCK:
+            self.out.append("\n")
+
+    def handle_data(self, data):
+        if self._in_title:
+            self.title += data
+        if self.skip:
+            return
+        self.out.append(data if self._pre else re.sub(r"\s+", " ", data))
+
+    def text(self) -> str:
+        raw = "".join(self.out)
+        raw = re.sub(r"[ \t]+\n", "\n", raw)
+        raw = re.sub(r"\n{3,}", "\n\n", raw)
+        return raw.strip()
+
+
+def _check_public(url: str) -> str:
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https") or not parsed.hostname:
+        raise ToolError("only http(s) URLs can be fetched")
+    host = parsed.hostname
+    try:
+        infos = socket.getaddrinfo(host, parsed.port or (443 if parsed.scheme == "https" else 80))
+    except socket.gaierror:
+        raise ToolError(f"could not resolve {host}")
+    for info in infos:
+        ip = ipaddress.ip_address(info[4][0].split("%")[0])
+        if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved or ip.is_multicast:
+            raise ToolError(f"{host} resolves to a private or local address ({ip}); refusing to fetch it")
+    return host
+
+
+def fetch_url(url: str, max_chars: int = 30000, offset: int = 0) -> str:
+    if not re.match(r"^https?://", url):
+        url = "https://" + url
+    _check_public(url)
+    try:
+        with httpx.Client(timeout=TIMEOUT, follow_redirects=False, headers={"User-Agent": USER_AGENT}) as client:
+            for _ in range(5):  # follow redirects manually so every hop is checked
+                with client.stream("GET", url) as resp:
+                    if resp.is_redirect and resp.headers.get("location"):
+                        url = str(resp.url.join(resp.headers["location"]))
+                        _check_public(url)
+                        continue
+                    if resp.status_code >= 400:
+                        raise ToolError(f"HTTP {resp.status_code} for {url}")
+                    ctype = resp.headers.get("content-type", "")
+                    body = b""
+                    for chunk in resp.iter_bytes():
+                        body += chunk
+                        if len(body) > MAX_DOWNLOAD:
+                            break
+                    break
+            else:
+                raise ToolError("too many redirects")
+    except httpx.HTTPError as e:
+        raise ToolError(f"fetch failed: {type(e).__name__}: {e}")
+
+    text = body.decode(resp.encoding or "utf-8", errors="replace")
+    if "html" in ctype or text.lstrip()[:15].lower().startswith(("<!doctype", "<html")):
+        parser = _TextExtractor(url)
+        parser.feed(text)
+        title = parser.title.strip()
+        text = (f"# {title}\n\n" if title else "") + parser.text()
+    elif not any(t in ctype for t in ("text", "json", "xml", "javascript")) and ctype:
+        raise ToolError(f"unsupported content type {ctype}")
+    # Continuous window, not a middle cut: metadata often sits mid-page (sidebars, release info).
+    offset = max(0, min(offset, len(text)))
+    chunk = text[offset:offset + max_chars]
+    end = offset + len(chunk)
+    header = f"[{url} · chars {offset}-{end} of {len(text)}]"
+    more = (f"\n\n[... {len(text) - end} more chars. Call web_fetch with the same url and offset={end} "
+            "to read on.]") if end < len(text) else ""
+    return f"{header}\n\n{chunk}{more}"
+
+
+# ----- tools -----------------------------------------------------------------
+
+class WebSearch(Tool):
+    name = "web_search"
+    description = ("Search the web. Returns titles, URLs and snippets. Use for current information, docs, "
+                   "error messages and library versions; then web_fetch the most relevant result.")
+    parameters = {"type": "object", "properties": {
+        "query": {"type": "string", "description": "Search query"},
+        "max_results": {"type": "integer", "description": f"1-{MAX_RESULTS} (default 8)"},
+    }, "required": ["query"]}
+    kind = "read"
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self.config = config or {}
+
+    def target(self, args):
+        return args.get("query", "")
+
+    def run(self, args, ctx: ToolContext):
+        limit = max(1, min(int(args.get("max_results") or 8), MAX_RESULTS))
+        results = web_search(args["query"], limit, self.config)
+        if not results:
+            return f"No results for '{args['query']}'."
+        lines = [f"Results for '{args['query']}':"]
+        for i, r in enumerate(results, 1):
+            lines.append(f"{i}. {r['title']}\n   {r['url']}\n   {r['snippet'][:300]}")
+        return "\n".join(lines)
+
+
+class WebFetch(Tool):
+    name = "web_fetch"
+    description = ("Fetch a web page or text file by URL and return its readable text (HTML is converted "
+                   "to plain text with headings and links). Use after web_search, or for URLs the user gives.")
+    parameters = {"type": "object", "properties": {
+        "url": {"type": "string", "description": "http(s) URL"},
+        "max_chars": {"type": "integer", "description": "Max characters to return (default 30000)"},
+        "offset": {"type": "integer", "description": "Character offset to continue a long page (default 0)"},
+    }, "required": ["url"]}
+    kind = "web"
+
+    def target(self, args):
+        """Permission rules match the domain, e.g. web_fetch(docs.python.org)."""
+        url = args.get("url", "")
+        host = urlparse(url if "://" in url else "https://" + url).hostname or url
+        return host.lower()
+
+    def preview(self, args, ctx):
+        return args.get("url", "")
+
+    def run(self, args, ctx: ToolContext):
+        return fetch_url(args["url"], max(1000, min(int(args.get("max_chars") or 30000), 60000)),
+                         int(args.get("offset") or 0))

hubble_cli-4.0.0.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: hubble-cli
+Version: 4.0.0
+Summary: Hubble: agentic coding CLI for AIHub and other OpenAI-compatible APIs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Hamdayrabby/hubble-cli
+Project-URL: Repository, https://github.com/Hamdayrabby/hubble-cli
+Project-URL: Changelog, https://github.com/Hamdayrabby/hubble-cli/blob/main/CHANGELOG.md
+Keywords: cli,agent,coding-assistant,llm,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt_toolkit>=3.0.40
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# Hubble
+
+An agentic coding CLI in the style of Claude Code, Antigravity/Gemini CLI and Codex CLI. It works directly
+in your repository: it searches, reads and edits files and runs commands through native function calling,
+and you approve each action. It talks to any OpenAI-compatible API — the AIHub gateway by default, or
+OpenAI, Groq, OpenRouter, Mistral, a local Ollama server, or others via `/provider add`.
+
+## Install
+
+```bash
+pipx install git+https://github.com/Hamdayrabby/hubble-cli.git
+```
+(or `pip install --user git+https://github.com/Hamdayrabby/hubble-cli.git` if you don't use pipx)
+
+Then just run it from any project:
+
+```bash
+cd /path/to/your/project
+hubble
+```
+
+With no API key configured anywhere, the first run walks you through adding one — no manual `.env` editing
+required. To set one up yourself instead, put it in `.env` in your project or in `~/.hubble/.env`:
+```
+HUBBLE_API_KEY=your_key_here
+HUBBLE_BASE_URL=https://aihub.071129.xyz/v1   # or any other OpenAI-compatible base URL
+```
+
+**From a local clone**, for development: `pip install -e .` from the repo root installs the `hubble`
+command (`aihub` also works, kept as an alias) against your working copy — edits take effect immediately.
+Without installing at all: `python code_cli.py [args]` from the repo root (add `--cwd <project>` to work
+elsewhere). The original single-file prototype is still there as `python chat_cli.py`.
+
+## Usage
+
+```bash
+hubble                                   # interactive REPL
+hubble "explain the architecture"        # REPL with a first prompt
+hubble -c                                # continue the latest session in this folder
+hubble -r                                # choose a session to resume
+hubble -p "fix the failing test" --permission-mode accept-edits --allow "shell(pytest*)"
+git diff | hubble -p "review this diff" --output-format json
+hubble -m nvidia/nemotron-3-super-120b-a12b --persona architect
+hubble --test codestral-latest           # check that a model responds
+```
+
+## Tools the model can use
+
+| Tool | What it does |
+|---|---|
+| `read_file` | Read with line numbers, `offset`/`limit` for large files |
+| `edit_file` | Exact string replace; must be unique unless `replace_all`; keeps CRLF |
+| `write_file` | Create or overwrite a file (existing files must be read first) |
+| `shell` | Run a command in the workspace root (PowerShell on Windows), with timeout and closed stdin |
+| `grep` | Regex search (ripgrep if installed, otherwise Python) |
+| `glob` | Find files by pattern, newest first |
+| `list_dir` | List a directory |
+| `todo_write` | Task list for multi-step work, shown in the terminal |
+| `task` | Read-only sub-agent for broad research; returns a report |
+| `web_search` | Web search. DuckDuckGo by default (no key); set `BRAVE_API_KEY` or `TAVILY_API_KEY` to use those instead |
+| `web_fetch` | Fetch a URL as readable text, page by page (`offset`). Asks once per domain; refuses local and private addresses |
+
+Safety:
+- **Workspace confinement:** paths outside the workspace are refused. Add others with `additional_dirs`.
+- **Secret files are blocked:** `.env`, `*.pem`, `id_rsa` and similar are never read, searched or attached (`allow_secret_files` turns this off).
+- **Edits need a fresh read:** a file must be read before it is edited or overwritten, and read again if it changed on disk since.
+- **Undo:** every change is snapshotted, so `/undo` can revert it.
+
+**Shell commands are not sandboxed by default** — they run directly on your machine with your own
+permissions, same as anything you'd type yourself. Approval prompts are the only protection unless you
+turn on the Docker sandbox below.
+
+### Sandboxed shell execution (optional)
+
+With [Docker Desktop](https://www.docker.com/products/docker-desktop/) installed, shell commands can run
+inside an isolated, disposable container instead of directly on your machine:
+
+```
+/sandbox on
+```
+or in `~/.hubble/settings.json` / `.hubble/settings.json`:
+```json
+{
+  "shell_sandbox": "docker",
+  "sandbox_image": "python:3.12-slim",
+  "sandbox_memory": "1g",
+  "sandbox_cpus": "2",
+  "sandbox_network": true
+}
+```
+Only the project folder is mounted in (as `/workspace`); nothing else on your machine is reachable from
+inside it. Memory and CPU are capped, and the container is removed after every command. Set
+`sandbox_image` to whatever your project needs (e.g. `node:20` for a JS project); set `sandbox_network` to
+`false` to also block network access from inside the sandbox, if your workflow doesn't need `pip`/`npm`
+install-style commands. Like `permission_mode`, `shell_sandbox` and `sandbox_network` only take effect from
+a project's own `.hubble/settings.json` once you've trusted that folder — an untrusted, freshly cloned
+project can't quietly turn sandboxing off or re-enable network access on your behalf.
+
+## Permission modes
+
+Cycle with **Shift+Tab** or set with `/mode` or `--permission-mode`:
+
+| Mode | Behaviour |
+|---|---|
+| `default` | Ask before every edit and shell command. The prompt shows a diff or the command. |
+| `accept-edits` | Edits are auto-approved. Shell commands still ask. |
+| `plan` | Read-only. The model explores and proposes a plan. |
+| `yolo` | Everything is auto-approved except deny rules. |
+
+At an approval prompt:
+- `y` allows the action once.
+- `a` allows it for the rest of the session: all edits, or commands with the same prefix, e.g. `pytest*`.
+- `n` denies it. You can add feedback, which is sent to the model.
+- Ctrl+C stops the turn.
+
+Allow rules never apply to chained commands (`&&`, `;`, `|`, redirects), so `shell(git status*)` does not approve `git status && rm -rf x`.
+
+## In-session commands
+
+| Input | Action |
+|---|---|
+| `/help` | All commands and shortcuts |
+| `/model [name\|#]`, `/models [filter]` | Switch or list models (latencies from `python test_models.py`) |
+| `/mode [mode]` | Permission mode |
+| `/persona [code\|debug\|review\|architect\|chat]` | System persona |
+| `/clear` | New conversation |
+| `/compact [focus]` | Summarize history to free context (automatic at 80%) |
+| `/resume [#\|id]` | Resume a saved session |
+| `/undo` | Revert files changed in the last turn that edited files |
+| `/diff` | Show `git diff` |
+| `/init` | Generate `HUBBLE.md` project instructions |
+| `/memory` | Show loaded memory files |
+| `/add <file>`, `/drop <file>`, `/files` | Pin files into the system prompt |
+| `/todos`, `/cost`, `/context`, `/config`, `/test [model]`, `/temp [t]`, `/export [file]` | Info and utilities |
+| `@path` | Attach a file (or directory listing) to your message; Tab completes paths |
+| `!cmd` | Run a shell command yourself |
+| `#note` | Append a note to `./HUBBLE.md` |
+| Esc+Enter / Ctrl+J | New line |
+| Ctrl+C / Ctrl+D | Cancel turn / quit |
+
+**Custom commands:** `.hubble/commands/<name>.md` (project) or `~/.hubble/commands/<name>.md` (user) becomes
+`/<name>`. `$ARGUMENTS` is replaced by the text after the command.
+
+## Providers (extra base URLs and API keys)
+
+Any OpenAI-compatible API can be added next to the built-in AIHub gateway: OpenRouter, Groq, OpenAI, Mistral,
+Gemini's OpenAI endpoint, a local Ollama server, and others.
+
+1. Type `/provider add`, or open `/provider` and choose **+ Add a provider**.
+2. Pick a known provider or **Custom URL...**, then paste the API key. The key is hidden as you type.
+3. The CLI checks the URL and key by listing the provider's models. If the check fails, it tells you why: wrong key, wrong URL, or can't connect.
+4. Optionally, the CLI checks which models actually respond, in the background. Progress shows in the bottom bar.
+5. Choose whether to switch to the new provider now. If you do, a model picker for that provider opens.
+
+After that:
+- `/model` lists models from every provider and switches provider automatically. The choice is saved as your default.
+- `/provider` switches provider, `/provider list` shows all of them, and `/provider remove <name>` deletes one.
+- `hubble --provider <name>` picks a provider for one run.
+- On first start with no API key at all, the same setup runs instead of an error.
+
+Extra providers are stored in `~/.hubble/providers.json`, with their API keys in plain text, like a `.env` file.
+Their model lists are stored in `~/.hubble/models/<name>.json`. When a model is rate limited or down, Hubble retries that request with a fallback that the current provider actually has, in this order: the fallback you picked with `/fallback`, then `fallback_model` if the provider has it, then the provider's fastest verified model, then `fallback_model` on the built-in hubble provider. Sub-agents use the same route. `/fallback off` disables it for a provider.
+
+## Project memory
+
+On startup the CLI loads `~/.hubble/HUBBLE.md`, then one of `HUBBLE.md`, `AGENTS.md`, `CLAUDE.md` or `GEMINI.md`
+from each directory between the git root and the workspace, into the system prompt.
+
+## Configuration
+
+Settings merge in order (later wins):
+1. Built-in defaults
+2. `~/.hubble/settings.json`
+3. `.hubble/settings.json`
+4. `.hubble/settings.local.json`
+5. CLI flags
+
+```json
+{
+  "model": "codestral-latest",
+  "max_tokens": 8192,
+  "context_window": 128000,
+  "permission_mode": "default",
+  "shell": "auto",
+  "additional_dirs": [],
+  "permissions": {
+    "allow": ["shell(pytest*)", "shell(git status*)", "shell(git diff*)"],
+    "deny": ["shell(git push*)", "edit_file(migrations/*)"]
+  }
+}
+```
+
+- Rule syntax is `tool` or `tool(glob)`. The glob is matched against the path or the command.
+- `bash`, `edit`, `write` and `read` work as aliases for the tool names.
+- Deny rules win over allow rules.
+- `shell` can be `auto` (pwsh, then Windows PowerShell), `cmd` or `bash`.
+
+Project settings files (`.hubble/*.json`) come from the repository, so they are treated as untrusted:
+- They can never set `base_url` or `api_key`.
+- `permission_mode`, `allow_secret_files`, `additional_dirs`, `shell` and allow rules apply only after you trust the folder. The CLI asks once and remembers the answer in `~/.hubble/trusted_folders.json`.
+- Deny rules always apply.
+
+Credentials come from `HUBBLE_API_KEY` / `HUBBLE_BASE_URL` in the environment, `.env` in your project, or `~/.hubble/.env`.
+Only `AIHUB_*` keys are read from those files.
+
+Sessions are saved as JSONL in `~/.hubble/projects/<project>/`. Input history is in `~/.hubble/history`.
+
+## Layout
+
+```
+hubble/
+  main.py         CLI flags, headless -p mode, resume
+  repl.py         prompt_toolkit REPL, slash commands, @mentions
+  ui.py           rich rendering: streamed markdown, diffs, approval prompts
+  agent.py        agent loop, compaction, task sub-agent
+  provider.py     OpenAI-compatible SSE client, retries, tool-call assembly
+  tools.py        workspace tools, sandbox, checkpoints
+  permissions.py  modes and allow/deny rules
+  session.py      JSONL transcripts
+  prompts.py      system prompt, personas, memory files
+  settings.py     layered settings and .env loading
+  models.py       model registry (shared with config.py)
+tests/            pytest suite (python -m pytest -q)
+```
+
+## Models on AIHub
+
+Hubble checks which models actually respond in the background: automatically every time it starts (for
+every provider you have configured), and on demand with `/models refresh`. `/models` shows the results and
+how long ago they were checked. Set `"model_refresh_hours"` in `~/.hubble/settings.json` to a positive number
+to only recheck once the list is that many hours old instead of on every start, or `null` to turn the
+automatic check off entirely (`/models refresh` still works). The check is one tiny request per model, so it
+costs a little on paid APIs.
+
+Running `python test_models.py` does the same scan for the built-in provider from the command line.
+The last scan found 33 working models out of 295.
+
+| Category | Models |
+|---|---|
+| Coding (default) | `codestral-latest`, `codestral-2508`, `mistral-code-latest`, `mistral-code-fim-latest` |
+| Reasoning | `nvidia/nemotron-3-super-120b-a12b`, `intern-s2-preview`, `intern-s1-mini`, `intern-s1` |
+| Fast chat | `ministral-14b-latest`, `open-mistral-nemo`, `ministral-8b-latest`, `ministral-3b-latest` |
+| Vision | `meta/llama-3.2-11b-vision-instruct`, `internvl3.5-latest`, `internvl-latest` |
+
+Native tool calling was verified on `codestral-latest`, `mistral-code-latest`, `ministral-14b-latest` and
+`nvidia/nemotron-3-super-120b-a12b`.

hubble_cli-4.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+hubble/__init__.py,sha256=LEviQFt085eioP3wuOxDjdgZoLFq_sb35Y_N0lMxv2o,105
+hubble/__main__.py,sha256=XjL0Sd1rAHrHv3_FiRTDA-Z5iM5BQPLeIPnvenhf9oI,68
+hubble/agent.py,sha256=oUbve6Er_UKsIv09Zyf3LxPrgVRUUsii7FD-_NbY8BA,25871
+hubble/banner.py,sha256=wuyYk332xiz3e3jn54I1-qSxPIjzTxCbxmSemNae8Vk,19866
+hubble/board.py,sha256=1SZ6EvP7pHIIZKVpnc6IsBIcaK5fKoxjNhQT2C6Q3_I,4628
+hubble/main.py,sha256=JNX3ARUWHjed4Or94GNrRVv4_JVvY80A_iMNeDYoi_g,13647
+hubble/models.py,sha256=o7DUgwupRyeRwio6KtDPhMF1Fcqz5alYbF7fo5wNIdQ,2860
+hubble/onboarding.py,sha256=VZnRCuFR8izyVKndtd305QdFUC4FvsuEkj9STuY_D3A,3905
+hubble/permissions.py,sha256=6IzHedsGrnCsyhGhET1BxEu7WhZxyEAluxk06DMzL3A,5948
+hubble/prompts.py,sha256=aKQ_2Ty7z-Q9KGeq5DFO3aPOLpLxM1B5Qu2h-5atDvg,7817
+hubble/provider.py,sha256=jGcCYlu0Fk_wj6K-sUlBY_a7wYqEJZM_mDw0g40WggI,11622
+hubble/providers.py,sha256=OtY_8idOceYwB_E95AaX0qOhNM8o3R3yHmyr0L8AGHc,7878
+hubble/repl.py,sha256=Cor3BKWITvFTRSIALP75lXZ_Hf0ne-6xdrhl0LObxqQ,47933
+hubble/scanner.py,sha256=TRh5XX-qbq-YXO5tLBRWPoZ5cWFPlk_ryUhIfJ4HLvs,5751
+hubble/session.py,sha256=n639MddGQK37Oo5BUNNIMwf6N8h5t_h52BiH_P46v_o,5184
+hubble/settings.py,sha256=4IEYjXscviHkV4LqWRqO1h8Hf4orffW9U3Oh_u7fpD4,6873
+hubble/skills.py,sha256=gQholahVCflzqk6CSnFVcF7agyHvzkwsZf_rIPTfzVc,7559
+hubble/spinner.py,sha256=Wt_rmzhBn1SAYixy2kjVwju5IlSACuXAg0PNJZYTe8M,2780
+hubble/tools.py,sha256=5VzK5hPFpIHQcqkjVWrTRREaNo53VOSZY6X9MNTl7uM,32844
+hubble/ui.py,sha256=BR49USTzmI051XHBx50PsWGz72XKn6KUdOY2lstgIv0,18831
+hubble/web.py,sha256=8RneXMH4NQAoQDBdcNsF6_QjeLr9U1ZQOXYuWa0t8Uc,12015
+hubble_cli-4.0.0.dist-info/licenses/LICENSE,sha256=7V8iNeMhHCxShIZUJn-twzCxfvMCiYIpWUZqtuigrkk,1077
+hubble_cli-4.0.0.dist-info/METADATA,sha256=CbxVtPi7bbzdC8XT2_1syaSVqHf1rfrfeRv2ualQOm4,13480
+hubble_cli-4.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hubble_cli-4.0.0.dist-info/entry_points.txt,sha256=kB02dm3At88fhIrS3_oZs7WYFtIbddHQTm1WHgJEKY8,69
+hubble_cli-4.0.0.dist-info/top_level.txt,sha256=qRONSj2uSA-PR_NbvC3igK1Sy-yOB7obA4lxjpcZASY,7
+hubble_cli-4.0.0.dist-info/RECORD,,

hubble_cli-4.0.0.dist-info/WHEEL

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

hubble_cli-4.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+aihub = hubble.main:main
+hubble = hubble.main:main

hubble_cli-4.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hamday Rabby Hossain
+
+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.

hubble_cli-4.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hubble