deuscode 0.1.0__tar.gz → 0.2.0__tar.gz

deuscode-0.2.0/.gitignore

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

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

@@ -1,12 +1,17 @@
 Metadata-Version: 2.4
 Name: deuscode
-Version: 0.1.0
+Version: 0.2.0
 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.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deuscode"
-version = "0.1.0"
+version = "0.2.0"
 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.2.0/src/deuscode/__init__.py

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

deuscode-0.2.0/src/deuscode/agent.py

@@ -0,0 +1,81 @@
+import json
+
+import httpx
+
+from deuscode.config import Config
+from deuscode.repomap import generate_repo_map
+from deuscode import tools, ui
+
+_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:
+        return await _loop(client, messages, model, config)
+
+
+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

deuscode-0.2.0/src/deuscode/config.py

@@ -0,0 +1,42 @@
+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,
+}
+
+
+@dataclass
+class Config:
+    base_url: str
+    api_key: str
+    model: str
+    max_tokens: int
+
+
+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"]),
+    )
+
+
+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.2.0/src/deuscode/main.py

@@ -0,0 +1,35 @@
+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()

deuscode-0.2.0/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.2.0/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.2.0/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.2.0/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.2.0/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()