dragon-cli 0.2.0__py3-none-any.whl

dragon_cli/setup_llm.py

@@ -0,0 +1,197 @@
+"""Cross-platform installer for llama-cpp-python.
+
+Compiling llama-cpp-python from source requires a C/C++ toolchain (Visual
+Studio Build Tools on Windows, gcc/build-essential on Linux, Xcode command
+line tools on macOS). This detects the current OS and GPU hardware, then
+installs the appropriate prebuilt wheel (CPU, CUDA, or ROCm) for optimal
+performance.
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+
+
+WHEEL_INDEX_URLS = {
+    "cpu": "https://abetlen.github.io/llama-cpp-python/whl/cpu",
+    "cuda": "https://abetlen.github.io/llama-cpp-python/whl/cu124",
+    "rocm": "https://abetlen.github.io/llama-cpp-python/whl/rocm",
+    "mps": "https://abetlen.github.io/llama-cpp-python/whl/metal",
+}
+
+
+def detect_gpu():
+    """Detect available GPU and return GPU type.
+
+    Prefer system commands such as nvidia-smi and rocm-smi because they work
+    even in stripped-down virtual environments where torch or CUDA libraries
+    may not be installed yet.
+    """
+    gpu_type = "cpu"
+
+    nvidia_smi = shutil.which("nvidia-smi")
+    if nvidia_smi:
+        result = subprocess.run(
+            [nvidia_smi, "--query-gpu=name,memory.total", "--format=csv,noheader"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            first_line = next((line.strip() for line in result.stdout.splitlines() if line.strip()), "")
+            if first_line:
+                gpu_name = first_line.split(",")[0].strip()
+                print(f"[dragon-cli] Detected NVIDIA GPU via nvidia-smi: {gpu_name}")
+                gpu_type = "cuda"
+                return gpu_type
+
+    if platform.system() == "Linux":
+        rocminfo = shutil.which("rocminfo")
+        if rocminfo:
+            result = subprocess.run(
+                [rocminfo],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0 and "Agent" in result.stdout:
+                print("[dragon-cli] Detected AMD GPU via ROCm")
+                return "rocm"
+
+        rocm_smi = shutil.which("rocm-smi")
+        if rocm_smi:
+            result = subprocess.run(
+                [rocm_smi, "--showproductname"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0:
+                print("[dragon-cli] Detected AMD GPU via rocm-smi")
+                return "rocm"
+
+    if platform.system() == "Darwin":
+        system_profiler = shutil.which("system_profiler")
+        if system_profiler:
+            result = subprocess.run(
+                [system_profiler, "SPDisplaysDataType"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+            if result.returncode == 0 and "Apple" in result.stdout:
+                print("[dragon-cli] Detected Apple Silicon GPU via system_profiler")
+                return "mps"
+
+    print("[dragon-cli] No dedicated GPU detected, using CPU-only mode")
+    return gpu_type
+
+
+def prompt_backend_choice(gpu_type: str) -> str:
+    """Ask the user in English which backend to use.
+
+    CPU remains the default backend for safety, even if a GPU is detected.
+    """
+    if gpu_type == "cpu":
+        print("[dragon-cli] No dedicated GPU detected. Defaulting to CPU backend.")
+        return "cpu"
+
+    print("[dragon-cli] GPU detected. Do you want to use a GPU-enabled wheel?")
+    print("[dragon-cli] Default backend: CPU")
+    print("[dragon-cli] Available backends: cpu, cuda, rocm, mps")
+
+    if not sys.stdin.isatty():
+        print("[dragon-cli] Non-interactive shell detected. Keeping CPU as the default backend.")
+        return "cpu"
+
+    answer = input("[dragon-cli] Choose backend [cpu]: ").strip().lower()
+    if answer in {"cpu", "cuda", "rocm", "mps"}:
+        return answer
+    if answer == "":
+        return "cpu"
+
+    print("[dragon-cli] Invalid choice. Keeping CPU as the default backend.")
+    return "cpu"
+
+
+def get_install_command(backend: str):
+    """Install llama-cpp-python using a prebuilt wheel backend.
+
+    CPU is the safe default; GPU backends can be selected later by the user.
+    """
+    index_url = WHEEL_INDEX_URLS.get(backend, WHEEL_INDEX_URLS["cpu"])
+    print(f"[dragon-cli] Installing llama-cpp-python from prebuilt {backend.upper()} wheels ({index_url})...")
+
+    result = subprocess.run([
+        sys.executable, "-m", "pip", "install", "llama-cpp-python",
+        "--prefer-binary", "--extra-index-url", index_url,
+    ])
+
+    return result
+
+
+TROUBLESHOOTING = {
+    "Windows": (
+        "Installation failed. Make sure you have Visual Studio Build Tools\n"
+        "with C++ workload installed:\n"
+        "https://visualstudio.microsoft.com/visual-cpp-build-tools/\n"
+        "Also ensure CMake is installed and in PATH."
+    ),
+    "Linux": (
+        "Installation failed. Install build tools and CMake:\n"
+        "  Ubuntu/Debian: sudo apt install build-essential cmake\n"
+        "  Fedora/RHEL: sudo dnf install gcc gcc-c++ make cmake\n"
+        "\nFor GPU support, also install:\n"
+        "  NVIDIA CUDA: https://developer.nvidia.com/cuda-downloads\n"
+        "  AMD ROCm: https://rocm.docs.amd.com/"
+    ),
+    "Darwin": (
+        "Installation failed. Install Xcode command line tools:\n"
+        "  xcode-select --install\n"
+        "\nFor Apple Silicon, ensure you're using Python from python.org or Homebrew."
+    ),
+}
+
+
+def main() -> None:
+    system = platform.system()
+    print(f"[dragon-cli] Detected {system} ({platform.machine()}), Python {platform.python_version()}")
+    print()
+
+    gpu_type = detect_gpu()
+    print()
+
+    backend = prompt_backend_choice(gpu_type)
+    print()
+
+    result = get_install_command(backend)
+
+    if result.returncode == 0:
+        print()
+        print("[dragon-cli] ✓ llama-cpp-python installed successfully!")
+
+        if backend != "cpu":
+            print(f"[dragon-cli] GPU backend selected ({backend.upper()})")
+            print("[dragon-cli] GPU-enabled wheel installed successfully")
+        else:
+            print("[dragon-cli] CPU backend selected by default")
+            print("[dragon-cli] You can choose a GPU wheel later if needed")
+
+        return
+
+    print("\n[dragon-cli] ✗ Installation failed.")
+    print(TROUBLESHOOTING.get(
+        system,
+        "Install a C/C++ toolchain and CMake for your platform, then retry: "
+        "pip install llama-cpp-python",
+    ))
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

dragon_cli/storage/__init__.py

@@ -0,0 +1,3 @@
+from .conversations import Conversation, ConversationStore, Message
+
+__all__ = ["Conversation", "ConversationStore", "Message"]

dragon_cli/storage/conversations.py

@@ -0,0 +1,134 @@
+"""High-level conversation persistence API used by the chat layer."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .database import connect
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class Conversation:
+    id: int
+    title: str
+    model_name: str | None
+    created_at: str
+    updated_at: str
+    message_count: int = 0
+
+
+@dataclass
+class Message:
+    role: str
+    content: str
+    created_at: str
+
+
+class ConversationStore:
+    """CRUD + search/export over the conversations/messages SQLite tables."""
+
+    def __init__(self, db_path: Path):
+        self.conn = connect(db_path)
+
+    def create(self, title: str, model_name: str | None = None) -> int:
+        now = _now()
+        cur = self.conn.execute(
+            "INSERT INTO conversations (title, model_name, created_at, updated_at) VALUES (?, ?, ?, ?)",
+            (title, model_name, now, now),
+        )
+        self.conn.commit()
+        return cur.lastrowid
+
+    def list(self) -> list[Conversation]:
+        rows = self.conn.execute(
+            """
+            SELECT c.id, c.title, c.model_name, c.created_at, c.updated_at,
+                   COUNT(m.id) AS message_count
+            FROM conversations c
+            LEFT JOIN messages m ON m.conversation_id = c.id
+            GROUP BY c.id
+            ORDER BY c.updated_at DESC
+            """
+        ).fetchall()
+        return [Conversation(**dict(r)) for r in rows]
+
+    def get(self, conv_id: int) -> tuple[Conversation, list[Message]] | None:
+        row = self.conn.execute("SELECT * FROM conversations WHERE id = ?", (conv_id,)).fetchone()
+        if row is None:
+            return None
+        msg_rows = self.conn.execute(
+            "SELECT role, content, created_at FROM messages WHERE conversation_id = ? ORDER BY id",
+            (conv_id,),
+        ).fetchall()
+        messages = [Message(**dict(m)) for m in msg_rows]
+        conv = Conversation(
+            id=row["id"], title=row["title"], model_name=row["model_name"],
+            created_at=row["created_at"], updated_at=row["updated_at"],
+            message_count=len(messages),
+        )
+        return conv, messages
+
+    def append_message(self, conv_id: int, role: str, content: str) -> None:
+        now = _now()
+        self.conn.execute(
+            "INSERT INTO messages (conversation_id, role, content, created_at) VALUES (?, ?, ?, ?)",
+            (conv_id, role, content, now),
+        )
+        self.conn.execute("UPDATE conversations SET updated_at = ? WHERE id = ?", (now, conv_id))
+        self.conn.commit()
+
+    def rename(self, conv_id: int, title: str) -> bool:
+        cur = self.conn.execute(
+            "UPDATE conversations SET title = ?, updated_at = ? WHERE id = ?", (title, _now(), conv_id)
+        )
+        self.conn.commit()
+        return cur.rowcount > 0
+
+    def delete(self, conv_id: int) -> bool:
+        cur = self.conn.execute("DELETE FROM conversations WHERE id = ?", (conv_id,))
+        self.conn.commit()
+        return cur.rowcount > 0
+
+    def search(self, text: str) -> list[tuple[int, str, str, str]]:
+        rows = self.conn.execute(
+            """
+            SELECT c.id, c.title, m.role, m.content
+            FROM messages m
+            JOIN conversations c ON c.id = m.conversation_id
+            WHERE m.content LIKE ?
+            ORDER BY m.created_at DESC
+            """,
+            (f"%{text}%",),
+        ).fetchall()
+        return [(r["id"], r["title"], r["role"], r["content"]) for r in rows]
+
+    def export(self, conv_id: int, path: Path, fmt: str = "md") -> Path | None:
+        found = self.get(conv_id)
+        if found is None:
+            return None
+        conv, messages = found
+        if fmt == "json":
+            payload = {
+                "id": conv.id, "title": conv.title, "model_name": conv.model_name,
+                "created_at": conv.created_at, "updated_at": conv.updated_at,
+                "messages": [{"role": m.role, "content": m.content, "created_at": m.created_at} for m in messages],
+            }
+            path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        else:
+            lines = [f"# {conv.title}", f"_model: {conv.model_name or 'unknown'} · updated: {conv.updated_at}_", ""]
+            for m in messages:
+                if m.role == "system":
+                    continue
+                lines.append(f"**{m.role}:** {m.content}\n")
+            path.write_text("\n".join(lines), encoding="utf-8")
+        return path
+
+    def close(self) -> None:
+        self.conn.close()

dragon_cli/storage/database.py

@@ -0,0 +1,32 @@
+"""SQLite connection and schema management for conversation storage."""
+
+import sqlite3
+from pathlib import Path
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS conversations (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    title       TEXT NOT NULL,
+    model_name  TEXT,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    conversation_id INTEGER NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+    role            TEXT NOT NULL,
+    content         TEXT NOT NULL,
+    created_at      TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id);
+"""
+
+
+def connect(db_path: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.executescript(SCHEMA)
+    return conn

dragon_cli/web.py

@@ -0,0 +1,112 @@
+"""HTML landing page and favicon for the --serve HTTP server."""
+
+# A dragon emoji rendered as SVG text works as a favicon with zero image
+# assets to ship, and doubles as the landing page's hero icon.
+FAVICON_SVG = (
+    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">'
+    '<text x="32" y="50" font-size="52" text-anchor="middle">\U0001F409</text>'
+    "</svg>"
+)
+
+_INDEX_TEMPLATE = """<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Dragon CLI — __MODEL_NAME__</title>
+<link rel="icon" type="image/svg+xml" href="/favicon.ico">
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; padding: 2.5rem 1.5rem 4rem;
+    background: #0b0f14; color: #d7e0ea;
+    font-family: -apple-system, Segoe UI, Helvetica, Arial, sans-serif;
+    line-height: 1.55;
+  }
+  main { max-width: 720px; margin: 0 auto; }
+  header { display: flex; align-items: center; gap: 1rem; margin-bottom: 0.5rem; }
+  .dragon { font-size: 3rem; line-height: 1; }
+  h1 { margin: 0; font-size: 1.6rem; color: #eef4fa; }
+  .subtitle { margin: 0.15rem 0 0; color: #7fe0d1; font-size: 0.95rem; }
+  .card {
+    background: #121924; border: 1px solid #212c3a; border-radius: 10px;
+    padding: 1rem 1.25rem; margin: 1.75rem 0;
+  }
+  .card h2 { margin-top: 0; font-size: 1.05rem; color: #7fe0d1; }
+  .kv { display: grid; grid-template-columns: auto 1fr; gap: 0.35rem 1rem; font-size: 0.92rem; }
+  .kv dt { color: #8a97a8; }
+  .kv dd { margin: 0; font-family: ui-monospace, Consolas, monospace; word-break: break-all; }
+  pre {
+    background: #0d1420; border: 1px solid #1c2634; border-radius: 8px;
+    padding: 0.9rem 1rem; overflow-x: auto; font-size: 0.85rem;
+    color: #c7e8ff;
+  }
+  code { font-family: ui-monospace, Consolas, monospace; }
+  a { color: #67c9ff; }
+  footer { margin-top: 2.5rem; color: #62707f; font-size: 0.85rem; }
+</style>
+</head>
+<body>
+<main>
+  <header>
+    <span class="dragon">\U0001F409</span>
+    <div>
+      <h1>Dragon CLI</h1>
+      <p class="subtitle">local model server — OpenAI-compatible API</p>
+    </div>
+  </header>
+
+  <div class="card">
+    <dl class="kv">
+      <dt>Model</dt><dd>__MODEL_NAME__</dd>
+      <dt>Base URL</dt><dd>__BASE_URL__</dd>
+    </dl>
+  </div>
+
+  <div class="card">
+    <h2>Interactive API docs</h2>
+    <p><a href="/docs">Swagger UI</a> &middot; <a href="/redoc">ReDoc</a> &middot;
+       <a href="/openapi.json">OpenAPI schema</a></p>
+  </div>
+
+  <div class="card">
+    <h2>List models</h2>
+    <pre><code>curl __BASE_URL__/v1/models</code></pre>
+  </div>
+
+  <div class="card">
+    <h2>Chat completion</h2>
+    <pre><code>curl __BASE_URL__/v1/chat/completions \\
+  -H "Content-Type: application/json" \\
+  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'</code></pre>
+    <p>Add <code>"stream": true</code> to the JSON body for server-sent-events streaming.</p>
+  </div>
+
+  <div class="card">
+    <h2>Python (OpenAI SDK)</h2>
+    <pre><code>from openai import OpenAI
+
+client = OpenAI(base_url="__BASE_URL_SLASH_V1__", api_key="not-needed")
+resp = client.chat.completions.create(
+    model="__MODEL_NAME__",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+print(resp.choices[0].message.content)</code></pre>
+  </div>
+
+  <footer>No MCP tool-calling on this endpoint — model only. Started with <code>dragon-cli --serve</code>.</footer>
+</main>
+</body>
+</html>
+"""
+
+
+def render_index(model_name: str, base_url: str) -> str:
+    base = base_url.rstrip("/")
+    return (
+        _INDEX_TEMPLATE
+        .replace("__MODEL_NAME__", model_name)
+        .replace("__BASE_URL_SLASH_V1__", f"{base}/v1")
+        .replace("__BASE_URL__", base)
+    )

dragon_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: dragon-cli
+Version: 0.2.0
+Summary: CLI to chat with local GGUF LLMs, with MCP tool-calling and SQLite conversation history.
+Author: JPEDROPS092
+License-Expression: MIT
+Project-URL: Homepage, https://jpedrops092.github.io/dragon-cli-ai-local/
+Project-URL: Repository, https://github.com/JPEDROPS092/dragon-cli-ai-local
+Project-URL: Issues, https://github.com/JPEDROPS092/dragon-cli-ai-local/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: huggingface_hub
+Requires-Dist: psutil
+Requires-Dist: mcp
+Requires-Dist: fastapi
+Requires-Dist: starlette
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Provides-Extra: llm
+Requires-Dist: llama-cpp-python; extra == "llm"
+Dynamic: license-file
+
+# Dragon CLI
+
+![1785346956957](image/README/1785346956957.png)
+
+[![License: MIT](https://img.shields.io/github/license/JPEDROPS092/dragon-cli-ai-local)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+[![Docs](<https://img.shields.io/badge/docs-GitHub%20Pages-7fe0d1>)](https://jpedrops092.github.io/dragon-cli-ai-local/)
+[![GitHub stars](https://img.shields.io/github/stars/JPEDROPS092/dragon-cli-ai-local?style=social)](https://github.com/JPEDROPS092/dragon-cli-ai-local/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/JPEDROPS092/dragon-cli-ai-local)](https://github.com/JPEDROPS092/dragon-cli-ai-local/issues)
+
+Chat with local GGUF LLMs (100% CPU, via `llama-cpp-python`), with optional
+MCP (Model Context Protocol) tool-calling and a SQLite-backed conversation
+history.
+
+## Install
+
+```bash
+pip install -e .
+dragon-cli-install-llm
+```
+
+This exposes a `dragon-cli` command. `llama-cpp-python` is intentionally kept
+out of the core dependencies, since it ships as C++ source on PyPI for many
+platforms — a plain `pip install` would try to compile it locally and fail
+without a C/C++ toolchain (Visual Studio Build Tools on Windows, gcc on
+Linux, Xcode command line tools on macOS).
+
+`dragon-cli-install-llm` detects your OS/architecture (Windows, Linux, or
+macOS) and installs a prebuilt CPU wheel instead, so a compiler usually isn't
+needed at all. If no prebuilt wheel is available for your exact
+platform/Python combination, it prints the toolchain to install and the
+fallback command to run.
+
+If you already have a working C/C++ toolchain and would rather build from
+source yourself, skip the installer and use the extra instead:
+`pip install -e ".[llm]"`.
+
+You can also run it without installing:
+
+```bash
+python dragon_cli.py
+# or
+python -m dragon_cli
+```
+
+## Usage
+
+```bash
+dragon-cli                       # model menu + chat
+dragon-cli --model 2             # skip the model menu
+dragon-cli --list                # just list the model catalog
+dragon-cli --no-mcp              # disable MCP connectors
+dragon-cli --resume 3            # resume saved conversation #3
+dragon-cli --list-conversations  # list saved conversations and exit
+dragon-cli --db path/to/other.db # use a different conversation database
+dragon-cli --serve               # serve the model over HTTP instead of chatting
+dragon-cli --serve --port 8080   # custom port (default: 8000)
+dragon-cli --serve --host 0.0.0.0  # expose beyond localhost (e.g. to your LAN) — opt-in only
+```
+
+## HTTP server (`--serve`)
+
+`dragon-cli --serve` loads a model and exposes it over a minimal
+OpenAI-compatible HTTP API instead of starting the interactive chat. It's
+built on FastAPI, so interactive docs come for free:
+
+- `GET /` — landing page with usage examples
+- `GET /docs` — Swagger UI
+- `GET /redoc` — ReDoc
+- `GET /openapi.json` — raw OpenAPI schema
+- `GET /v1/models` — lists the currently loaded model
+- `POST /v1/chat/completions` — same shape as OpenAI's endpoint, streaming
+  (`"stream": true`, server-sent events) and non-streaming both supported,
+  request body validated (422 with a clear error on malformed input)
+
+Point any OpenAI-compatible client/SDK at `http://127.0.0.1:8000/v1` (adjust
+host/port to match `--host`/`--port`) and it works without extra glue code.
+This mode does **not** expose MCP tool-calling — it's the model only,
+kept intentionally simple and predictable. It also binds to `127.0.0.1` by
+default (only reachable from your own machine); pass `--host 0.0.0.0`
+explicitly if you want it reachable from other devices on your network.
+
+## In-chat commands
+
+| Command                    | Description                         |
+| -------------------------- | ----------------------------------- |
+| `/help`                  | show available commands             |
+| `/models`                | list the model catalog              |
+| `/tools`                 | list connected MCP tools            |
+| `/mcp`                   | show MCP server connection status   |
+| `/clear`                 | clear the current in-memory history |
+| `/new [title]`           | start a new conversation            |
+| `/list`                  | list saved conversations            |
+| `/resume <id>`           | resume a saved conversation         |
+| `/rename <id> <title>`   | rename a saved conversation         |
+| `/delete <id>`           | delete a saved conversation         |
+| `/search <text>`         | search saved messages for text      |
+| `/export <id> [md\|json]` | export a conversation to a file     |
+| `/exit`, `/quit`       | end the program                     |
+
+Every message is autosaved to SQLite (`dragon_cli.db` by default) as soon as
+it's sent, so nothing is lost if the process crashes.
+
+## MCP connectors
+
+On first run, an example `mcp_servers.json` is created in the working
+directory. Edit it to point at your MCP servers and restart to connect.
+
+## Project layout
+
+```
+src/dragon_cli/
+├── cli.py            # argparse entry point
+├── app.py             # model selection + orchestration
+├── setup_llm.py        # cross-platform llama-cpp-python installer
+├── server.py            # OpenAI-compatible HTTP server (--serve)
+├── banner.py            # ASCII banner
+├── config.py             # shared paths/colors
+├── models/            # model catalog, download, loading
+├── mcp/                # MCP server manager + tool-call parsing
+├── storage/            # SQLite conversation store
+└── chat/                # chat session, streaming, slash commands
+```

dragon_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+dragon_cli/__init__.py,sha256=tSPFdYJBXGD8urB1CBZJO6WSwA-itm6EMxXp-oUf90o,87
+dragon_cli/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+dragon_cli/_cuda.py,sha256=q2EDpKtIE1WCs1NwKqWTWzLHhw-Kc7GGCJ4A9vdX1A8,1343
+dragon_cli/app.py,sha256=2xmllRuySzep1MkExQaIWhaZFlU2WXhaT6fR7j3eUbY,4232
+dragon_cli/banner.py,sha256=uKDhnNTkuNZVSnmafHaMbVS0urmK6oPIpeole52me4k,3968
+dragon_cli/cli.py,sha256=MenxJaLekcbBnuXOp7Rj4nT6kP-OYgGXnDj9JBmW93I,6430
+dragon_cli/config.py,sha256=-4QYyPh2WOcaOyJf6XLXGsuG5KzrUeD5mcT4VygInrg,700
+dragon_cli/hardware.py,sha256=_buxSPWLc38bOPzsxR8tiOYZTslOoj6QaAZ2cUPcmzs,13054
+dragon_cli/menu.py,sha256=2R23yLYeYiNaPKiBzdya8pXlX_oghkNXEJ-jFO00_kM,47271
+dragon_cli/model_hub.py,sha256=0NRR0wXJH2d9-YpAHctNEuR8cIdEUYcxEd-c5Z1LlEg,8171
+dragon_cli/recommendation.py,sha256=9bhw2lV_LGY0dk1UNUr4Jh1UID7HvWJMorNZSTiEc2M,10845
+dragon_cli/runtime.py,sha256=ZdmM5eZrPeMeydkZaAZFwWw2omlS3aG5iEJSZJ6Uw1o,8395
+dragon_cli/server.py,sha256=mp235Ehwhbn2uv5leMSZR2a6UZ85-gWFyiwU_lenzVM,5666
+dragon_cli/setup_llm.py,sha256=LVj-XFsYEW_Jje5bj2aPWDMXX8mJTI1LrtLU8Zb5FsA,6645
+dragon_cli/web.py,sha256=KG4Ji89ex2aK_BAMettZfjKfxdXgsYyVeeno0niD_8s,3730
+dragon_cli/chat/__init__.py,sha256=0gvbs-QAH1xwE_GXz-dEBzI-UFjgkL60PsfrvHkGHSk,148
+dragon_cli/chat/commands.py,sha256=ec_V0HIgXnqsYGmjX7MYOqIsA8u72xDO1FplUe-NnWA,5753
+dragon_cli/chat/session.py,sha256=HSiqPTl7fEKWyPtw6uP7A381Izt_ZhIkrIPcmgkcUCg,3840
+dragon_cli/chat/streaming.py,sha256=P-sJ1VmRCirxpKX8crIQdtVyy_06psdqgQM9sQVmXl4,555
+dragon_cli/mcp/__init__.py,sha256=kWwXepBx7phIfRl9qfm5TB2L6mhnwWjCVoLimy5KMdU,243
+dragon_cli/mcp/manager.py,sha256=s-L037Go6VbHGdOW65wCZtyWYfoYH3luaswc1VYcjGc,6041
+dragon_cli/mcp/tool_call.py,sha256=nCvkUvMo3-wJXO628UZEMtzkjt65wDwYioWAEtg9agc,433
+dragon_cli/models/__init__.py,sha256=HtQADqyoNjL9dbk0mGoMu3AnLGoZIWYfFdwgqP5g7mE,280
+dragon_cli/models/catalog.py,sha256=F5Jn2BdK1C2LAAtQcEpR1m3_2NpxBqms2Rb4cZ--Lv8,7701
+dragon_cli/models/loader.py,sha256=KybLGUDKMEHwrNHgRSB9kN2rt3FzIdVSQuSLwI3tBDQ,6951
+dragon_cli/storage/__init__.py,sha256=11JtsPqCen-9xkUKXUxeVqDtAYwUhXiTmNrDMfyVLWc,128
+dragon_cli/storage/conversations.py,sha256=5aGfrzFYQlAtT8EiaOgMw2La_OQfR909fgoibzBwulc,4671
+dragon_cli/storage/database.py,sha256=7Mc74FFDsYveOj3P0ZMT4sNfMH_hb93FFeSd-S_HXP8,932
+dragon_cli-0.2.0.dist-info/licenses/LICENSE,sha256=6Fd0LBu1a_4jvyuo71J5dwl16ToLI1nYBckfIogXjcE,1068
+dragon_cli-0.2.0.dist-info/METADATA,sha256=8wOg1XeMEJtjlET8nLuns_54OHtvqLWXNfpAao3cEeY,6409
+dragon_cli-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+dragon_cli-0.2.0.dist-info/entry_points.txt,sha256=oDjJQZyVKWMIp8mCw08qcIlJSPTpQhyIWvmgjfk0ktQ,102
+dragon_cli-0.2.0.dist-info/top_level.txt,sha256=_6Q26X07zb3vGpQJ4xnpjUdWI4h2FEN7o9nTBvUDz3Q,11
+dragon_cli-0.2.0.dist-info/RECORD,,

dragon_cli-0.2.0.dist-info/WHEEL

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

dragon_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dragon-cli = dragon_cli.cli:main
+dragon-cli-install-llm = dragon_cli.setup_llm:main