deuscode 0.1.0__tar.gz → 0.3.1__tar.gz

deuscode-0.3.1/.gitignore

@@ -0,0 +1,8 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.py[cod]
+.venv/
+.env
+.claude/

{deuscode-0.1.0 → deuscode-0.3.1}/PKG-INFO

@@ -1,12 +1,17 @@
 Metadata-Version: 2.4
 Name: deuscode
-Version: 0.1.0
+Version: 0.3.1
 Summary: AI-powered multi-agent CLI coding assistant for local LLMs
 License: AGPL-3.0-or-later
 License-File: LICENSE
 Requires-Python: >=3.12
+Requires-Dist: httpx
+Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # deuscode

{deuscode-0.1.0 → deuscode-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deuscode"
-version = "0.1.0"
+version = "0.3.1"
 description = "AI-powered multi-agent CLI coding assistant for local LLMs"
 readme = "README.md"
 license = { text = "AGPL-3.0-or-later" }
@@ -12,6 +12,14 @@ requires-python = ">=3.12"
 dependencies = [
     "typer",
     "rich",
+    "httpx",
+    "pyyaml",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-asyncio",
 ]
 
 [project.scripts]
@@ -19,3 +27,6 @@ deus = "deuscode.main:app"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/deuscode"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

deuscode-0.3.1/src/deuscode/__init__.py

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

deuscode-0.3.1/src/deuscode/agent.py

@@ -0,0 +1,100 @@
+import json
+
+import httpx
+import yaml
+
+from deuscode.config import Config, CONFIG_PATH
+from deuscode.repomap import generate_repo_map
+from deuscode import tools, ui, runpod
+
+_SYSTEM_BASE = (
+    "You are Deus, an AI coding assistant. "
+    "You have access to tools to read/write files and run shell commands. "
+    "Always explain what you are doing before calling a tool."
+)
+
+
+async def run(
+    prompt: str,
+    config: Config,
+    path: str = ".",
+    model_override: str | None = None,
+    no_map: bool = False,
+) -> str:
+    model = model_override or config.model
+    system_prompt = _build_system_prompt(path, no_map)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": prompt},
+    ]
+    ui.thinking(model)
+    async with httpx.AsyncClient(timeout=120.0) as client:
+        result = await _loop(client, messages, model, config)
+    await _maybe_auto_stop(config)
+    return result
+
+
+def _build_system_prompt(path: str, no_map: bool) -> str:
+    if no_map:
+        return _SYSTEM_BASE
+    repo_map = generate_repo_map(path)
+    return f"{_SYSTEM_BASE}\n\n## Repo Map\n{repo_map}"
+
+
+async def _loop(client: httpx.AsyncClient, messages: list, model: str, config: Config) -> str:
+    while True:
+        data = await _chat(client, messages, model, config)
+        choice = data["choices"][0]
+        msg = choice["message"]
+        messages.append(msg)
+
+        tool_calls = msg.get("tool_calls") or []
+        if not tool_calls:
+            return msg.get("content") or ""
+
+        for tc in tool_calls:
+            result = await _execute_tool(tc)
+            messages.append({
+                "role": "tool",
+                "tool_call_id": tc["id"],
+                "content": result,
+            })
+
+
+async def _chat(client: httpx.AsyncClient, messages: list, model: str, config: Config) -> dict:
+    response = await client.post(
+        f"{config.base_url.rstrip('/')}/chat/completions",
+        headers={"Authorization": f"Bearer {config.api_key}", "Content-Type": "application/json"},
+        json={
+            "model": model,
+            "messages": messages,
+            "tools": tools.TOOL_SCHEMAS,
+            "max_tokens": config.max_tokens,
+        },
+    )
+    response.raise_for_status()
+    return response.json()
+
+
+async def _execute_tool(tc: dict) -> str:
+    fn = tc["function"]
+    ui.tool_call(fn["name"], json.loads(fn.get("arguments", "{}")))
+    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.3.1/src/deuscode/config.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from dataclasses import dataclass
+
+import yaml
+
+CONFIG_PATH = Path.home() / ".deus" / "config.yaml"
+
+_DEFAULTS = {
+    "base_url": "https://your-runpod-endpoint/v1",
+    "api_key": "your-key",
+    "model": "your-model-name",
+    "max_tokens": 8192,
+    "auto_stop_runpod": False,
+}
+
+
+@dataclass
+class Config:
+    base_url: str
+    api_key: str
+    model: str
+    max_tokens: int
+    auto_stop_runpod: bool = False
+
+
+def load_config() -> Config:
+    if not CONFIG_PATH.exists():
+        _create_default_config()
+        raise FileNotFoundError(
+            f"Config created at {CONFIG_PATH} — please fill in your endpoint details."
+        )
+    data = yaml.safe_load(CONFIG_PATH.read_text()) or {}
+    merged = {**_DEFAULTS, **data}
+    return Config(
+        base_url=merged["base_url"],
+        api_key=merged["api_key"],
+        model=merged["model"],
+        max_tokens=int(merged["max_tokens"]),
+        auto_stop_runpod=bool(merged.get("auto_stop_runpod", False)),
+    )
+
+
+def _create_default_config() -> None:
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(yaml.dump(_DEFAULTS, default_flow_style=False))

deuscode-0.3.1/src/deuscode/main.py

@@ -0,0 +1,56 @@
+import asyncio
+from typing import Optional
+
+import typer
+
+from deuscode import ui
+from deuscode.config import load_config
+from deuscode import agent
+from deuscode.setup import run_setup_runpod, run_stop_runpod
+
+app = typer.Typer(invoke_without_command=True, help="Deus - AI-powered CLI coding assistant")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    prompt: Optional[str] = typer.Argument(None, 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:
+    if ctx.invoked_subcommand is not None:
+        return
+    if not prompt:
+        ui.error("Provide a prompt or use a subcommand (e.g. deus setup --runpod)")
+        raise typer.Exit(1)
+    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)
+
+
+@app.command()
+def setup(
+    runpod: bool = typer.Option(False, "--runpod", help="Configure a RunPod GPU endpoint"),
+    stop: bool = typer.Option(False, "--stop", help="Stop the current RunPod pod"),
+) -> None:
+    """Configure Deus endpoints and models."""
+    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")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

deuscode-0.3.1/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.1/src/deuscode/repomap.py

@@ -0,0 +1,69 @@
+import ast
+import re
+from pathlib import Path
+
+MAX_CHARS = 4000
+SKIP_DIRS = {".git", "node_modules", "vendor", "__pycache__", ".venv", "dist", "build"}
+SKIP_FILES = {".env"}
+
+
+def generate_repo_map(path: str) -> str:
+    root = Path(path).resolve()
+    lines: list[str] = []
+    _walk(root, root, lines)
+    output = "\n".join(lines)
+    _SUFFIX = "\n... [truncated]"
+    if len(output) > MAX_CHARS:
+        output = output[: MAX_CHARS - len(_SUFFIX)] + _SUFFIX
+    return output
+
+
+def _walk(root: Path, current: Path, lines: list[str], depth: int = 0) -> None:
+    indent = "  " * depth
+    for item in sorted(current.iterdir()):
+        if item.name in SKIP_DIRS or item.name in SKIP_FILES:
+            continue
+        if item.name.startswith("."):
+            continue
+        if item.is_dir():
+            lines.append(f"{indent}{item.name}/")
+            _walk(root, item, lines, depth + 1)
+        elif item.is_file():
+            _append_file_entry(item, indent, lines)
+
+
+def _append_file_entry(path: Path, indent: str, lines: list[str]) -> None:
+    if path.suffix == ".py":
+        sigs = _extract_python_signatures(path)
+        lines.append(f"{indent}{path.name}")
+        lines.extend(f"{indent}  {s}" for s in sigs)
+    elif path.suffix == ".php":
+        sigs = _extract_php_signatures(path)
+        lines.append(f"{indent}{path.name}")
+        lines.extend(f"{indent}  {s}" for s in sigs)
+    else:
+        lines.append(f"{indent}{path.name}")
+
+
+def _extract_python_signatures(path: Path) -> list[str]:
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8", errors="ignore"))
+    except SyntaxError:
+        return []
+    sigs: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            sigs.append(f"class {node.name}")
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            args = [a.arg for a in node.args.args]
+            sigs.append(f"def {node.name}({', '.join(args)})")
+    return sigs
+
+
+def _extract_php_signatures(path: Path) -> list[str]:
+    text = path.read_text(encoding="utf-8", errors="ignore")
+    classes = re.findall(r"class\s+(\w+)", text)
+    functions = re.findall(r"function\s+(\w+)\s*\(([^)]*)\)", text)
+    sigs: list[str] = [f"class {c}" for c in classes]
+    sigs += [f"function {n}({a.strip()})" for n, a in functions]
+    return sigs

deuscode-0.3.1/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.1/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.1/src/deuscode/tools.py

@@ -0,0 +1,115 @@
+import json
+import subprocess
+from pathlib import Path
+
+from deuscode import ui
+
+_CWD = Path.cwd().resolve()
+
+TOOL_SCHEMAS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read the contents of a file.",
+            "parameters": {
+                "type": "object",
+                "properties": {"path": {"type": "string", "description": "File path to read"}},
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Write content to a file after user confirmation.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path to write"},
+                    "content": {"type": "string", "description": "Content to write"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "bash",
+            "description": "Run a shell command after user confirmation.",
+            "parameters": {
+                "type": "object",
+                "properties": {"command": {"type": "string", "description": "Shell command to run"}},
+                "required": ["command"],
+            },
+        },
+    },
+]
+
+
+def _safe_path(path: str) -> Path | None:
+    resolved = Path(path).resolve()
+    if not str(resolved).startswith(str(_CWD)):
+        return None
+    return resolved
+
+
+async def read_file(path: str) -> str:
+    target = _safe_path(path)
+    if target is None:
+        return f"Error: path '{path}' is outside the working directory."
+    if not target.exists():
+        return f"Error: '{path}' does not exist."
+    return target.read_text(encoding="utf-8", errors="replace")
+
+
+async def write_file(path: str, content: str) -> str:
+    target = _safe_path(path)
+    if target is None:
+        return f"Error: path '{path}' is outside the working directory."
+    if target.exists():
+        existing = target.read_text(encoding="utf-8", errors="replace")
+        _show_diff(existing, content, path)
+    if not ui.confirm(f"Write to [bold]{path}[/bold]?"):
+        return "Cancelled by user."
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8")
+    return f"Written: {path}"
+
+
+async def bash(command: str) -> str:
+    ui.console.print(f"[bold yellow]Command:[/bold yellow] {command}")
+    if not ui.confirm("Run this command?"):
+        return "Cancelled by user."
+    result = subprocess.run(command, shell=True, capture_output=True, text=True)
+    output = result.stdout + result.stderr
+    return output.strip() or "(no output)"
+
+
+def _show_diff(old: str, new: str, path: str) -> None:
+    old_lines = old.splitlines()
+    new_lines = new.splitlines()
+    ui.console.print(f"[dim]Diff for {path}:[/dim]")
+    for line in old_lines:
+        if line not in new_lines:
+            ui.console.print(f"[red]- {line}[/red]")
+    for line in new_lines:
+        if line not in old_lines:
+            ui.console.print(f"[green]+ {line}[/green]")
+
+
+TOOL_FUNCTIONS = {
+    "read_file": read_file,
+    "write_file": write_file,
+    "bash": bash,
+}
+
+
+async def dispatch(name: str, args_json: str) -> str:
+    fn = TOOL_FUNCTIONS.get(name)
+    if fn is None:
+        return f"Error: unknown tool '{name}'"
+    args = json.loads(args_json)
+    return await fn(**args)

deuscode-0.3.1/src/deuscode/ui.py

@@ -0,0 +1,30 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+console = Console()
+
+
+def thinking(model: str) -> None:
+    console.print(f"[dim]Deus is thinking... ({model})[/dim]")
+
+
+def tool_call(name: str, args: dict) -> None:
+    args_str = ", ".join(f"{k}={v!r}" for k, v in args.items())
+    console.print(f"[yellow]⚡ Calling: {name}({args_str})[/yellow]")
+
+
+def tool_result(text: str) -> None:
+    console.print(f"[dim grey]{text}[/dim grey]")
+
+
+def final_answer(text: str) -> None:
+    console.print(Panel(text, title="[bold cyan]Deus[/bold cyan]", border_style="cyan"))
+
+
+def error(text: str) -> None:
+    console.print(Panel(text, title="[bold red]Error[/bold red]", border_style="red"))
+
+
+def confirm(prompt: str) -> bool:
+    return Confirm.ask(prompt)

deuscode-0.3.1/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.1/tests/test_repomap.py

@@ -0,0 +1,59 @@
+import textwrap
+from pathlib import Path
+
+import pytest
+
+from deuscode.repomap import generate_repo_map
+
+
+def _make_py(tmp_path: Path, name: str, src: str) -> Path:
+    f = tmp_path / name
+    f.write_text(textwrap.dedent(src))
+    return f
+
+
+def test_generates_tree(tmp_path):
+    _make_py(tmp_path, "alpha.py", "x = 1")
+    _make_py(tmp_path, "beta.py", "y = 2")
+    result = generate_repo_map(str(tmp_path))
+    assert "alpha.py" in result
+    assert "beta.py" in result
+    assert len(result) > 0
+
+
+def test_extracts_python_signatures(tmp_path):
+    _make_py(tmp_path, "module.py", """\
+        class Foo:
+            pass
+
+        def bar(x, y):
+            pass
+
+        async def baz(z):
+            pass
+    """)
+    result = generate_repo_map(str(tmp_path))
+    assert "class Foo" in result
+    assert "def bar" in result
+    assert "def baz" in result
+
+
+def test_skips_ignored_dirs(tmp_path):
+    (tmp_path / ".git").mkdir()
+    (tmp_path / ".git" / "config").write_text("gitconfig")
+    (tmp_path / "node_modules").mkdir()
+    (tmp_path / "node_modules" / "pkg.js").write_text("module.exports={}")
+    _make_py(tmp_path, "app.py", "pass")
+    result = generate_repo_map(str(tmp_path))
+    assert ".git" not in result
+    assert "node_modules" not in result
+    assert "app.py" in result
+
+
+def test_truncates_large_repos(tmp_path):
+    for i in range(60):
+        src = "\n".join(f"def func_{j}(x): pass" for j in range(20))
+        (tmp_path / f"module_{i}.py").write_text(src)
+    result = generate_repo_map(str(tmp_path))
+    assert len(result) <= 4000
+    assert "truncated" in result

deuscode-0.3.1/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.1/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.3.1/tests/test_tools.py

@@ -0,0 +1,45 @@
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+import deuscode.tools as tool_module
+from deuscode.tools import read_file, write_file
+
+
+@pytest.fixture(autouse=True)
+def set_cwd(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(tool_module, "_CWD", tmp_path.resolve())
+
+
+@pytest.mark.asyncio
+async def test_read_file_success(tmp_path):
+    f = tmp_path / "hello.txt"
+    f.write_text("hello world")
+    result = await read_file(str(f))
+    assert result == "hello world"
+
+
+@pytest.mark.asyncio
+async def test_read_file_blocks_path_traversal(tmp_path):
+    result = await read_file("../../etc/passwd")
+    assert "Error" in result
+
+
+@pytest.mark.asyncio
+async def test_write_file_creates_file(tmp_path):
+    target = tmp_path / "output.txt"
+    with patch("deuscode.ui.confirm", return_value=True):
+        result = await write_file(str(target), "new content")
+    assert "Written" in result
+    assert target.read_text() == "new content"
+
+
+@pytest.mark.asyncio
+async def test_write_file_rejects_outside_cwd(tmp_path):
+    outside = tmp_path.parent / "evil.txt"
+    result = await write_file(str(outside), "bad")
+    assert "Error" in result
+    assert not outside.exists()

deuscode-0.1.0/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:www.gnu.org)",
-      "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(pip install:*)",
-      "Bash(python:*)"
-    ]
-  }
-}

deuscode-0.1.0/src/deuscode/__init__.py

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

deuscode-0.1.0/src/deuscode/main.py

@@ -1,15 +0,0 @@
-import typer
-from rich.console import Console
-
-app = typer.Typer()
-console = Console()
-
-
-@app.command()
-def main():
-    """Deus - AI-powered multi-agent CLI coding assistant."""
-    console.print("[bold cyan]Deus v0.1.0[/bold cyan] [dim]- Coming soon[/dim]")
-
-
-if __name__ == "__main__":
-    app()