deuscode 0.2.0__tar.gz → 0.3.2__tar.gz

{deuscode-0.2.0 → deuscode-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deuscode
-Version: 0.2.0
+Version: 0.3.2
 Summary: AI-powered multi-agent CLI coding assistant for local LLMs
 License: AGPL-3.0-or-later
 License-File: LICENSE

{deuscode-0.2.0 → deuscode-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deuscode"
-version = "0.2.0"
+version = "0.3.2"
 description = "AI-powered multi-agent CLI coding assistant for local LLMs"
 readme = "README.md"
 license = { text = "AGPL-3.0-or-later" }

deuscode-0.3.2/src/deuscode/__init__.py

@@ -0,0 +1 @@
+version = "0.3.2"

{deuscode-0.2.0 → deuscode-0.3.2}/src/deuscode/agent.py

@@ -1,10 +1,11 @@
 import json
 
 import httpx
+import yaml
 
-from deuscode.config import Config
+from deuscode.config import Config, CONFIG_PATH
 from deuscode.repomap import generate_repo_map
-from deuscode import tools, ui
+from deuscode import tools, ui, runpod
 
 _SYSTEM_BASE = (
     "You are Deus, an AI coding assistant. "
@@ -13,6 +14,22 @@ _SYSTEM_BASE = (
 )
 
 
+async def run_agent(
+    prompt: str,
+    path: str = ".",
+    model_override: str | None = None,
+    no_map: bool = False,
+) -> None:
+    from deuscode.config import load_config
+    try:
+        config = load_config()
+    except FileNotFoundError as e:
+        ui.error(str(e))
+        return
+    result = await run(prompt, config, path=path, model_override=model_override, no_map=no_map)
+    ui.final_answer(result)
+
+
 async def run(
     prompt: str,
     config: Config,
@@ -28,7 +45,9 @@ async def run(
     ]
     ui.thinking(model)
     async with httpx.AsyncClient(timeout=120.0) as client:
-        return await _loop(client, messages, model, config)
+        result = await _loop(client, messages, model, config)
+    await _maybe_auto_stop(config)
+    return result
 
 
 def _build_system_prompt(path: str, no_map: bool) -> str:
@@ -79,3 +98,19 @@ async def _execute_tool(tc: dict) -> str:
     result = await tools.dispatch(fn["name"], fn.get("arguments", "{}"))
     ui.tool_result(result[:500])
     return result
+
+
+async def _maybe_auto_stop(config: Config) -> None:
+    if not config.auto_stop_runpod:
+        return
+    raw = yaml.safe_load(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
+    pod_id = raw.get("runpod_pod_id")
+    api_key = raw.get("runpod_api_key", "")
+    if not pod_id:
+        return
+    ui.console.print(f"[bold yellow]⚡ Auto-stopping RunPod pod {pod_id}...[/bold yellow]")
+    try:
+        await runpod.stop_pod(api_key, pod_id)
+        ui.console.print("[green]✓ Pod stopped. No more charges.[/green]")
+    except Exception as e:
+        ui.console.print(f"[red]Warning: could not stop pod {pod_id}: {e}[/red]")

{deuscode-0.2.0 → deuscode-0.3.2}/src/deuscode/config.py

@@ -10,6 +10,7 @@ _DEFAULTS = {
     "api_key": "your-key",
     "model": "your-model-name",
     "max_tokens": 8192,
+    "auto_stop_runpod": False,
 }
 
 
@@ -19,6 +20,7 @@ class Config:
     api_key: str
     model: str
     max_tokens: int
+    auto_stop_runpod: bool = False
 
 
 def load_config() -> Config:
@@ -34,6 +36,7 @@ def load_config() -> Config:
         api_key=merged["api_key"],
         model=merged["model"],
         max_tokens=int(merged["max_tokens"]),
+        auto_stop_runpod=bool(merged.get("auto_stop_runpod", False)),
     )
 
 

deuscode-0.3.2/src/deuscode/main.py

@@ -0,0 +1,56 @@
+import sys
+import asyncio
+from typing import Optional
+
+import typer
+
+from deuscode import ui
+from deuscode.agent import run_agent
+from deuscode.setup import run_setup_runpod, run_stop_runpod
+
+app = typer.Typer(
+    name="deus",
+    help="Deus - AI-powered CLI coding assistant",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+setup_app = typer.Typer(help="Configure Deus endpoints and models.")
+app.add_typer(setup_app, name="setup")
+
+
+@setup_app.callback(invoke_without_command=True)
+def setup_callback(
+    ctx: typer.Context,
+    runpod: bool = typer.Option(False, "--runpod", help="Configure RunPod GPU endpoint"),
+    stop: bool = typer.Option(False, "--stop", help="Stop the current RunPod pod"),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    if stop:
+        asyncio.run(run_stop_runpod())
+    elif runpod:
+        asyncio.run(run_setup_runpod())
+    else:
+        ui.error("Use --runpod to configure or --stop to stop pod")
+
+
+@app.command(name="ask", hidden=True)
+def ask(
+    prompt: str = typer.Argument(..., help="What to ask Deus"),
+    path: str = typer.Option(".", "--path", help="Repo path to map"),
+    model: Optional[str] = typer.Option(None, "--model", help="Override config model"),
+    no_map: bool = typer.Option(False, "--no-map", help="Skip repo-map"),
+) -> None:
+    asyncio.run(run_agent(prompt, path, model, no_map))
+
+
+def main() -> None:
+    known_subcommands = ["setup", "ask", "--help", "-h"]
+    if len(sys.argv) > 1 and sys.argv[1] not in known_subcommands:
+        sys.argv.insert(1, "ask")
+    app()
+
+
+if __name__ == "__main__":
+    main()

deuscode-0.3.2/src/deuscode/models.py

@@ -0,0 +1,57 @@
+from typing import TypedDict
+
+
+class ModelEntry(TypedDict):
+    id: str
+    label: str
+    category: str
+    vram_gb: int
+    description: str
+
+
+MODELS: list[ModelEntry] = [
+    {
+        "id": "Qwen/Qwen2.5-Coder-32B-Instruct",
+        "label": "Qwen2.5-Coder-32B",
+        "category": "Coding",
+        "vram_gb": 40,
+        "description": "Best coding model, recommended",
+    },
+    {
+        "id": "Qwen/Qwen2.5-Coder-7B-Instruct",
+        "label": "Qwen2.5-Coder-7B",
+        "category": "Coding",
+        "vram_gb": 16,
+        "description": "Fast and cheap coding model",
+    },
+    {
+        "id": "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",
+        "label": "DeepSeek-Coder-V2-Lite",
+        "category": "Coding",
+        "vram_gb": 24,
+        "description": "Strong coding alternative",
+    },
+    {
+        "id": "meta-llama/Llama-3.1-70B-Instruct",
+        "label": "Llama-3.1-70B",
+        "category": "General",
+        "vram_gb": 80,
+        "description": "Powerful general purpose",
+    },
+    {
+        "id": "meta-llama/Llama-3.1-8B-Instruct",
+        "label": "Llama-3.1-8B",
+        "category": "General",
+        "vram_gb": 16,
+        "description": "Fast general purpose",
+    },
+    {
+        "id": "mistralai/Mistral-7B-Instruct-v0.3",
+        "label": "Mistral-7B",
+        "category": "General",
+        "vram_gb": 16,
+        "description": "Lightweight, fast",
+    },
+]
+
+CUSTOM_MODEL_OPTION = "Custom (type manually)"

deuscode-0.3.2/src/deuscode/runpod.py

@@ -0,0 +1,97 @@
+import asyncio
+
+import httpx
+
+_API_URL = "https://api.runpod.io/graphql"
+_POLL_INTERVAL = 10
+_TIMEOUT_SECONDS = 300
+
+
+def _headers(api_key: str) -> dict:
+    return {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+
+async def get_gpu_types(api_key: str) -> list[dict]:
+    query = """
+    query {
+      gpuTypes {
+        id
+        displayName
+        memoryInGb
+        securePrice
+      }
+    }
+    """
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        r = await client.post(_API_URL, headers=_headers(api_key), json={"query": query})
+        r.raise_for_status()
+        return r.json()["data"]["gpuTypes"]
+
+
+async def start_pod(api_key: str, gpu_type_id: str, model_id: str) -> dict:
+    mutation = """
+    mutation($input: PodFindAndDeployOnDemandInput!) {
+      podFindAndDeployOnDemand(input: $input) {
+        id
+        desiredStatus
+      }
+    }
+    """
+    variables = {
+        "input": {
+            "gpuTypeId": gpu_type_id,
+            "imageName": "vllm/vllm-openai:latest",
+            "containerDiskInGb": 50,
+            "volumeInGb": 50,
+            "ports": "8000/http",
+            "env": [
+                {"key": "MODEL_ID", "value": model_id},
+                {"key": "HUGGING_FACE_HUB_TOKEN", "value": ""},
+            ],
+        }
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        r = await client.post(_API_URL, headers=_headers(api_key), json={"query": mutation, "variables": variables})
+        r.raise_for_status()
+        return r.json()["data"]["podFindAndDeployOnDemand"]
+
+
+async def stop_pod(api_key: str, pod_id: str) -> bool:
+    mutation = """
+    mutation($input: PodTerminateInput!) {
+      podTerminate(input: $input)
+    }
+    """
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        r = await client.post(_API_URL, headers=_headers(api_key), json={"query": mutation, "variables": {"input": {"podId": pod_id}}})
+        r.raise_for_status()
+        return True
+
+
+async def wait_for_ready(api_key: str, pod_id: str) -> str:
+    query = """
+    query($podId: String!) {
+      pod(input: { podId: $podId }) {
+        desiredStatus
+        runtime { ports { ip port isIpPublic } }
+      }
+    }
+    """
+    elapsed = 0
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        while elapsed < _TIMEOUT_SECONDS:
+            r = await client.post(_API_URL, headers=_headers(api_key), json={"query": query, "variables": {"podId": pod_id}})
+            r.raise_for_status()
+            pod = r.json()["data"]["pod"]
+            if pod["desiredStatus"] == "RUNNING":
+                return _extract_endpoint(pod)
+            await asyncio.sleep(_POLL_INTERVAL)
+            elapsed += _POLL_INTERVAL
+    raise TimeoutError(f"Pod {pod_id} did not become ready within {_TIMEOUT_SECONDS}s")
+
+
+def _extract_endpoint(pod: dict) -> str:
+    for port_info in (pod.get("runtime") or {}).get("ports") or []:
+        if port_info.get("isIpPublic") and port_info.get("port") == 8000:
+            return f"https://{port_info['ip']}:{port_info['port']}"
+    return ""

deuscode-0.3.2/src/deuscode/setup.py

@@ -0,0 +1,110 @@
+import yaml
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+
+from deuscode import ui
+from deuscode.config import CONFIG_PATH
+from deuscode.models import MODELS, CUSTOM_MODEL_OPTION
+from deuscode import runpod
+
+
+async def run_setup_runpod() -> None:
+    api_key = Prompt.ask("[bold]RunPod API key[/bold]", password=True)
+    model_entry = _pick_model()
+    model_id = model_entry["id"] if model_entry else Prompt.ask("Enter model ID")
+    vram_needed = model_entry["vram_gb"] if model_entry else 0
+
+    ui.console.print(f"\n[dim]Fetching GPUs with ≥{vram_needed} GB VRAM...[/dim]")
+    gpus = await runpod.get_gpu_types(api_key)
+    filtered = [g for g in gpus if (g.get("memoryInGb") or 0) >= vram_needed]
+    gpu = _pick_gpu(filtered)
+
+    price = gpu.get("securePrice") or "?"
+    if not Confirm.ask(f"This will cost ~${price}/hr. Continue?", default=False):
+        ui.console.print("[dim]Aborted.[/dim]")
+        return
+
+    auto_stop = Confirm.ask("Auto-stop RunPod pod after each prompt completes?", default=False)
+
+    pod_id = await _start_with_spinner(api_key, gpu["id"], model_id)
+    endpoint = await _wait_with_spinner(api_key, pod_id)
+    _save_config(endpoint, api_key, model_id, pod_id, auto_stop)
+    ui.final_answer(
+        f"✓ Deus is ready. Run: deus 'your prompt'\n\n"
+        f"⚠ Stop your pod manually anytime: deus setup --stop\n"
+        f"Current pod: {pod_id} (~${price}/hr)"
+    )
+
+
+async def run_stop_runpod() -> None:
+    if not CONFIG_PATH.exists():
+        ui.error("No active RunPod pod found in ~/.deus/config.yaml")
+        return
+    config_data = yaml.safe_load(CONFIG_PATH.read_text()) or {}
+    pod_id = config_data.get("runpod_pod_id")
+    if not pod_id:
+        ui.error("No active RunPod pod found in ~/.deus/config.yaml")
+        return
+    api_key = config_data.get("runpod_api_key", "")
+    ui.console.print(f"[dim]Stopping pod {pod_id}...[/dim]")
+    try:
+        success = await runpod.stop_pod(api_key, pod_id)
+    except Exception as e:
+        success = False
+        ui.error(f"Failed to stop pod {pod_id}: {e}\nStop manually at runpod.io/console")
+        return
+    if success:
+        config_data.pop("runpod_pod_id", None)
+        CONFIG_PATH.write_text(yaml.dump(config_data, default_flow_style=False))
+        ui.final_answer("✓ Pod stopped. No more charges.")
+    else:
+        ui.error(f"Failed to stop pod {pod_id}.\nStop manually at runpod.io/console")
+
+
+def _pick_model() -> dict | None:
+    table = Table(title="Available Models")
+    for col in ("#", "Model", "Category", "VRAM", "Description"):
+        table.add_column(col)
+    ordered = sorted(MODELS, key=lambda m: (0 if m["category"] == "Coding" else 1, m["label"]))
+    for i, m in enumerate(ordered, 1):
+        table.add_row(str(i), m["label"], m["category"], f"{m['vram_gb']} GB", m["description"])
+    table.add_row(str(len(ordered) + 1), CUSTOM_MODEL_OPTION, "", "", "")
+    ui.console.print(table)
+    idx = int(Prompt.ask("Pick a model", default="1")) - 1
+    return ordered[idx] if idx < len(ordered) else None
+
+
+def _pick_gpu(gpus: list[dict]) -> dict:
+    table = Table(title="Available GPUs")
+    for col in ("#", "GPU Name", "VRAM", "Price/hr"):
+        table.add_column(col)
+    for i, g in enumerate(gpus, 1):
+        table.add_row(str(i), g.get("displayName", ""), f"{g.get('memoryInGb', '?')} GB", f"${g.get('securePrice', '?')}")
+    ui.console.print(table)
+    idx = int(Prompt.ask("Pick a GPU", default="1")) - 1
+    return gpus[idx]
+
+
+async def _start_with_spinner(api_key: str, gpu_id: str, model_id: str) -> str:
+    ui.console.print("[dim]Starting pod...[/dim]")
+    pod = await runpod.start_pod(api_key, gpu_id, model_id)
+    return pod["id"]
+
+
+async def _wait_with_spinner(api_key: str, pod_id: str) -> str:
+    ui.console.print("[dim]Waiting for vLLM to be ready (this takes 2-3 min)...[/dim]")
+    return await runpod.wait_for_ready(api_key, pod_id)
+
+
+def _save_config(endpoint: str, api_key: str, model_id: str, pod_id: str, auto_stop: bool) -> None:
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    existing = yaml.safe_load(CONFIG_PATH.read_text()) if CONFIG_PATH.exists() else {}
+    existing.update({
+        "base_url": f"{endpoint}/v1",
+        "api_key": api_key,
+        "model": model_id,
+        "runpod_pod_id": pod_id,
+        "runpod_api_key": api_key,
+        "auto_stop_runpod": auto_stop,
+    })
+    CONFIG_PATH.write_text(yaml.dump(existing, default_flow_style=False))

deuscode-0.3.2/tests/test_models.py

@@ -0,0 +1,17 @@
+from deuscode.models import MODELS
+
+
+def test_all_models_have_required_fields():
+    required = {"id", "label", "category", "vram_gb", "description"}
+    for m in MODELS:
+        assert required <= m.keys(), f"Model missing fields: {m}"
+
+
+def test_vram_values_are_positive():
+    for m in MODELS:
+        assert m["vram_gb"] > 0, f"Non-positive vram_gb for {m['id']}"
+
+
+def test_no_duplicate_model_ids():
+    ids = [m["id"] for m in MODELS]
+    assert len(ids) == len(set(ids)), "Duplicate model IDs found"

deuscode-0.3.2/tests/test_runpod.py

@@ -0,0 +1,56 @@
+import json
+from unittest.mock import AsyncMock, patch, MagicMock
+
+import pytest
+
+from deuscode import runpod
+
+
+def _mock_response(data: dict, status: int = 200) -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = status
+    resp.json.return_value = data
+    resp.raise_for_status = MagicMock()
+    return resp
+
+
+@pytest.mark.asyncio
+async def test_stop_pod_sends_correct_id():
+    captured = {}
+
+    async def fake_post(url, **kwargs):
+        captured["body"] = kwargs.get("json", {})
+        return _mock_response({"data": {"podTerminate": None}})
+
+    with patch("deuscode.runpod.httpx.AsyncClient") as MockClient:
+        instance = AsyncMock()
+        instance.post.side_effect = fake_post
+        instance.__aenter__ = AsyncMock(return_value=instance)
+        instance.__aexit__ = AsyncMock(return_value=False)
+        MockClient.return_value = instance
+
+        await runpod.stop_pod("key123", "pod-abc")
+
+    variables = captured["body"].get("variables", {})
+    assert variables.get("input", {}).get("podId") == "pod-abc"
+
+
+@pytest.mark.asyncio
+async def test_wait_for_ready_timeout():
+    async def fake_post(url, **kwargs):
+        return _mock_response({
+            "data": {"pod": {"desiredStatus": "STARTING", "runtime": None}}
+        })
+
+    with patch("deuscode.runpod.httpx.AsyncClient") as MockClient, \
+         patch("deuscode.runpod._TIMEOUT_SECONDS", 1), \
+         patch("deuscode.runpod._POLL_INTERVAL", 1), \
+         patch("asyncio.sleep", new_callable=AsyncMock):
+        instance = AsyncMock()
+        instance.post.side_effect = fake_post
+        instance.__aenter__ = AsyncMock(return_value=instance)
+        instance.__aexit__ = AsyncMock(return_value=False)
+        MockClient.return_value = instance
+
+        with pytest.raises(TimeoutError):
+            await runpod.wait_for_ready("key123", "pod-xyz")

deuscode-0.3.2/tests/test_setup.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+from unittest.mock import AsyncMock, patch, MagicMock
+
+import pytest
+import yaml
+
+import deuscode.setup as deus_setup
+from deuscode.setup import run_stop_runpod
+
+
+def _write_config(tmp_path: Path, data: dict) -> Path:
+    cfg = tmp_path / "config.yaml"
+    cfg.write_text(yaml.dump(data))
+    return cfg
+
+
+@pytest.mark.asyncio
+async def test_run_stop_no_pod_id(tmp_path):
+    cfg = _write_config(tmp_path, {"runpod_api_key": "key"})
+    errors = []
+    with patch.object(deus_setup, "CONFIG_PATH", cfg), \
+         patch("deuscode.setup.ui.error", side_effect=lambda m: errors.append(m)), \
+         patch("deuscode.runpod.stop_pod", new_callable=AsyncMock) as mock_stop:
+        await run_stop_runpod()
+    assert any("No active RunPod pod" in e for e in errors)
+    mock_stop.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_run_stop_success(tmp_path):
+    cfg = _write_config(tmp_path, {"runpod_pod_id": "pod-123", "runpod_api_key": "key"})
+    with patch.object(deus_setup, "CONFIG_PATH", cfg), \
+         patch("deuscode.setup.runpod.stop_pod", new_callable=AsyncMock, return_value=True), \
+         patch("deuscode.setup.ui.final_answer"), \
+         patch("deuscode.setup.ui.console"):
+        await run_stop_runpod()
+    saved = yaml.safe_load(cfg.read_text()) or {}
+    assert "runpod_pod_id" not in saved
+
+
+@pytest.mark.asyncio
+async def test_run_stop_failure(tmp_path):
+    cfg = _write_config(tmp_path, {"runpod_pod_id": "pod-456", "runpod_api_key": "key"})
+    errors = []
+    with patch.object(deus_setup, "CONFIG_PATH", cfg), \
+         patch("deuscode.setup.runpod.stop_pod", new_callable=AsyncMock, return_value=False), \
+         patch("deuscode.setup.ui.error", side_effect=lambda m: errors.append(m)), \
+         patch("deuscode.setup.ui.console"):
+        await run_stop_runpod()
+    saved = yaml.safe_load(cfg.read_text()) or {}
+    assert saved.get("runpod_pod_id") == "pod-456"
+    assert any("pod-456" in e for e in errors)

deuscode-0.2.0/src/deuscode/__init__.py

@@ -1 +0,0 @@
-version = "0.2.0"

deuscode-0.2.0/src/deuscode/main.py

@@ -1,35 +0,0 @@
-import asyncio
-from typing import Optional
-
-import typer
-
-from deuscode import ui
-from deuscode.config import load_config
-from deuscode import agent
-
-app = typer.Typer(help="Deus - AI-powered CLI coding assistant")
-
-
-@app.command()
-def main(
-    prompt: str = typer.Argument(..., help="What to ask Deus"),
-    path: str = typer.Option(".", "--path", help="Repo path to map"),
-    model: Optional[str] = typer.Option(None, "--model", help="Override config model"),
-    no_map: bool = typer.Option(False, "--no-map", help="Skip repo-map generation"),
-) -> None:
-    try:
-        config = load_config()
-    except FileNotFoundError as e:
-        ui.error(str(e))
-        raise typer.Exit(1)
-
-    try:
-        result = asyncio.run(agent.run(prompt, config, path=path, model_override=model, no_map=no_map))
-        ui.final_answer(result)
-    except Exception as e:
-        ui.error(str(e))
-        raise typer.Exit(1)
-
-
-if __name__ == "__main__":
-    app()