duh-cli 0.2.0__py3-none-any.whl

duh/__init__.py

@@ -0,0 +1,6 @@
+"""D.U.H. — Duh is a Universal Harness.
+
+Because connecting AI to your codebase should be obvious.
+"""
+
+__version__ = "0.2.0"

duh/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running duh as `python -m duh`."""
+
+from duh.cli.main import main
+
+raise SystemExit(main())

duh/adapters/__init__.py

@@ -0,0 +1,6 @@
+"""Adapters — concrete implementations of ports.
+
+Each adapter wraps an external SDK/service and translates it into
+D.U.H.'s uniform interface. The kernel never imports these directly;
+they're injected via Deps.
+"""

duh/adapters/anthropic.py

@@ -0,0 +1,324 @@
+"""Anthropic adapter — wraps the anthropic Python SDK into D.U.H. events.
+
+This adapter translates between:
+- D.U.H. Messages → Anthropic API format (role/content dicts)
+- Anthropic streaming events → D.U.H. uniform events
+- Anthropic tool schemas → D.U.H. tool format
+
+Usage:
+    from duh.adapters.anthropic import AnthropicProvider
+    provider = AnthropicProvider(api_key="sk-ant-...")
+    deps = Deps(call_model=provider.stream)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any, AsyncGenerator
+
+import httpx
+
+from duh.kernel.backoff import with_backoff
+from duh.kernel.messages import Message
+
+
+class AnthropicProvider:
+    """Wraps the Anthropic Python SDK to produce D.U.H. uniform events.
+
+    Implements the ModelProvider port contract.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "claude-sonnet-4-6",
+        max_retries: int = 2,
+        timeout: float = 600.0,
+        base_url: str | None = None,
+    ):
+        import anthropic
+
+        self._default_model = model
+        self._client = anthropic.AsyncAnthropic(
+            api_key=api_key or os.environ.get("ANTHROPIC_API_KEY", ""),
+            max_retries=max_retries,
+            timeout=timeout,
+            **({"base_url": base_url} if base_url else {}),
+        )
+
+    async def stream(
+        self,
+        *,
+        messages: list[Any],
+        system_prompt: str | list[str] = "",
+        model: str = "",
+        tools: list[Any] | None = None,
+        thinking: dict[str, Any] | None = None,
+        max_tokens: int | None = None,
+        tool_choice: str | dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AsyncGenerator[dict[str, Any], None]:
+        """Stream model responses, yielding D.U.H. uniform events."""
+        resolved_model = model or self._default_model
+        resolved_max_tokens = max_tokens or _default_max_tokens(resolved_model)
+
+        # Build API params
+        api_messages = _to_api_messages(messages)
+        params: dict[str, Any] = {
+            "model": resolved_model,
+            "max_tokens": resolved_max_tokens,
+            "messages": api_messages,
+        }
+
+        # System prompt
+        system_text = _build_system_text(system_prompt)
+        if system_text:
+            params["system"] = system_text
+
+        # Tools
+        if tools:
+            params["tools"] = _to_api_tools(tools)
+
+        # Thinking
+        if thinking:
+            thinking_type = thinking.get("type", "disabled")
+            if thinking_type in ("adaptive", "enabled"):
+                supports_adaptive = any(
+                    tag in resolved_model
+                    for tag in ("opus-4-6", "sonnet-4-6")
+                )
+                if supports_adaptive:
+                    params["thinking"] = {"type": "adaptive"}
+                elif thinking_type == "enabled":
+                    budget = thinking.get("budget_tokens", resolved_max_tokens - 1)
+                    params["thinking"] = {"type": "enabled", "budget_tokens": budget}
+
+        # Tool choice — Anthropic supports natively
+        if tool_choice and tools:
+            if isinstance(tool_choice, dict):
+                params["tool_choice"] = tool_choice
+            elif tool_choice == "none":
+                # Don't send tools at all — simplest way to prevent tool use
+                del params["tools"]
+            elif tool_choice == "auto":
+                params["tool_choice"] = {"type": "auto"}
+            elif tool_choice == "any":
+                params["tool_choice"] = {"type": "any"}
+            else:
+                # Assume it's a tool name — force that specific tool
+                params["tool_choice"] = {"type": "tool", "name": tool_choice}
+
+        # Stream with exponential backoff for transient errors
+        content_blocks: list[Any] = []
+        accumulated_text: list[str] = []
+        usage: dict[str, int] = {}
+
+        async def _do_stream() -> AsyncGenerator[dict[str, Any], None]:
+            nonlocal content_blocks, accumulated_text, usage
+            # Reset accumulators on each retry attempt
+            content_blocks = []
+            accumulated_text = []
+            usage = {}
+
+            async with self._client.messages.stream(**params) as stream:
+                try:
+                    async for event in stream:
+                        event_type = getattr(event, "type", "")
+
+                        if event_type == "content_block_start":
+                            block = getattr(event, "content_block", None)
+                            if block:
+                                content_blocks.append(block)
+                            yield {
+                                "type": "content_block_start",
+                                "index": getattr(event, "index", len(content_blocks) - 1),
+                                "content_block": _block_to_dict(block) if block else {},
+                            }
+
+                        elif event_type == "content_block_delta":
+                            delta = getattr(event, "delta", None)
+                            if delta:
+                                delta_type = getattr(delta, "type", "")
+                                if delta_type == "text_delta":
+                                    text = getattr(delta, "text", "")
+                                    accumulated_text.append(text)
+                                    yield {"type": "text_delta", "text": text}
+                                elif delta_type == "thinking_delta":
+                                    yield {"type": "thinking_delta", "text": getattr(delta, "thinking", "")}
+                                elif delta_type == "input_json_delta":
+                                    yield {"type": "input_json_delta", "partial_json": getattr(delta, "partial_json", "")}
+                                elif delta_type == "signature_delta":
+                                    pass  # Ignore signature deltas
+
+                        elif event_type == "content_block_stop":
+                            yield {
+                                "type": "content_block_stop",
+                                "index": getattr(event, "index", 0),
+                            }
+
+                        elif event_type == "message_start":
+                            msg = getattr(event, "message", None)
+                            if msg:
+                                msg_usage = getattr(msg, "usage", None)
+                                if msg_usage:
+                                    usage = {
+                                        "input_tokens": getattr(msg_usage, "input_tokens", 0),
+                                        "output_tokens": getattr(msg_usage, "output_tokens", 0),
+                                    }
+
+                        elif event_type == "message_delta":
+                            delta_usage = getattr(event, "usage", None)
+                            if delta_usage:
+                                usage["output_tokens"] = getattr(delta_usage, "output_tokens", 0)
+
+                except (ConnectionError, httpx.ReadError, asyncio.TimeoutError) as mid_err:
+                    # Mid-stream error — yield partial content if we have any
+                    partial_text = "".join(accumulated_text)
+                    if partial_text:
+                        yield {
+                            "type": "assistant",
+                            "message": Message(
+                                role="assistant",
+                                content=[{"type": "text", "text": partial_text}],
+                                metadata={
+                                    "partial": True,
+                                    "model": resolved_model,
+                                    "stop_reason": "error",
+                                    "usage": usage,
+                                },
+                            ),
+                        }
+                    yield {"type": "error", "error": f"Stream interrupted: {mid_err}"}
+                    return
+
+                # Build final assistant message
+                final = await stream.get_final_message()
+                content = _normalize_content(list(final.content)) if final else []
+
+                assistant_msg = Message(
+                    role="assistant",
+                    content=content,
+                    id=getattr(final, "id", ""),
+                    metadata={
+                        "model": getattr(final, "model", resolved_model),
+                        "stop_reason": getattr(final, "stop_reason", "end_turn"),
+                        "usage": usage,
+                    },
+                )
+                yield {"type": "assistant", "message": assistant_msg}
+
+        try:
+            async for event in with_backoff(_do_stream):
+                yield event
+        except Exception as e:
+            error_text = str(e)
+            # Yield error as an assistant message with error content
+            yield {
+                "type": "assistant",
+                "message": Message(
+                    role="assistant",
+                    content=[{"type": "text", "text": f"API Error: {error_text}"}],
+                    metadata={"is_error": True, "error": error_text},
+                ),
+            }
+
+
+# ---------------------------------------------------------------------------
+# Translation helpers
+# ---------------------------------------------------------------------------
+
+def _to_api_messages(messages: list[Any]) -> list[dict[str, Any]]:
+    """Translate D.U.H. Messages → Anthropic API format."""
+    result = []
+    for msg in messages:
+        if isinstance(msg, Message):
+            content = msg.content
+            if isinstance(content, list):
+                # Convert dataclass blocks to dicts
+                api_content = []
+                for block in content:
+                    if isinstance(block, dict):
+                        # Strip to API-allowed fields per block type
+                        api_content.append(_sanitize_block(block))
+                    elif hasattr(block, "__dataclass_fields__"):
+                        from dataclasses import asdict
+                        api_content.append(_sanitize_block(asdict(block)))
+                    else:
+                        api_content.append({"type": "text", "text": str(block)})
+                result.append({"role": msg.role, "content": api_content})
+            else:
+                result.append({"role": msg.role, "content": str(content)})
+        elif isinstance(msg, dict):
+            result.append({"role": msg.get("role", "user"), "content": msg.get("content", "")})
+        else:
+            result.append({"role": "user", "content": str(msg)})
+    return result
+
+
+def _sanitize_block(block: dict[str, Any]) -> dict[str, Any]:
+    """Strip non-API fields from content blocks."""
+    ALLOWED = {
+        "text": {"type", "text"},
+        "tool_use": {"type", "id", "name", "input"},
+        "tool_result": {"type", "tool_use_id", "content", "is_error"},
+        "thinking": {"type", "thinking", "signature"},
+    }
+    bt = block.get("type", "")
+    allowed = ALLOWED.get(bt)
+    if allowed:
+        return {k: v for k, v in block.items() if k in allowed}
+    return block
+
+
+def _to_api_tools(tools: list[Any]) -> list[dict[str, Any]]:
+    """Translate D.U.H. Tool objects → Anthropic API tool schemas."""
+    result = []
+    for tool in tools:
+        if isinstance(tool, dict):
+            result.append(tool)
+        elif hasattr(tool, "name") and hasattr(tool, "input_schema"):
+            desc = getattr(tool, "description", "")
+            if callable(desc):
+                desc = desc()
+            result.append({
+                "name": tool.name,
+                "description": str(desc) if desc else "",
+                "input_schema": tool.input_schema,
+            })
+    return result
+
+
+def _build_system_text(system_prompt: str | list[str]) -> str:
+    """Build system prompt text."""
+    if isinstance(system_prompt, list):
+        return "\n\n".join(p for p in system_prompt if p)
+    return system_prompt
+
+
+def _default_max_tokens(model: str) -> int:
+    """Get default max tokens for a model."""
+    if "opus" in model:
+        return 16384
+    if "haiku" in model:
+        return 8192
+    return 16384  # sonnet default
+
+
+def _block_to_dict(block: Any) -> dict[str, Any]:
+    """Convert an SDK content block object to a dict."""
+    if isinstance(block, dict):
+        return block
+    if hasattr(block, "model_dump"):
+        return block.model_dump()
+    d: dict[str, Any] = {"type": getattr(block, "type", "unknown")}
+    for attr in ("text", "thinking", "id", "name", "input", "signature"):
+        val = getattr(block, attr, None)
+        if val is not None:
+            d[attr] = val
+    return d
+
+
+def _normalize_content(blocks: list[Any]) -> list[dict[str, Any]]:
+    """Normalize SDK content blocks to dicts."""
+    return [_block_to_dict(b) for b in blocks]

duh/adapters/approvers.py

@@ -0,0 +1,88 @@
+"""Approval gate adapters — permission checking implementations.
+
+AutoApprover: allows everything (sandbox/bypass mode)
+InteractiveApprover: asks the user y/n in the terminal
+RuleApprover: deny rules from config (path restrictions, command blocklists)
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+
+class AutoApprover:
+    """Allows all tool calls without prompting. For sandboxed environments."""
+
+    async def check(self, tool_name: str, input: dict[str, Any]) -> dict[str, Any]:
+        return {"allowed": True}
+
+
+class InteractiveApprover:
+    """Asks the user for permission before tool execution."""
+
+    def __init__(self, *, default_allow: bool = False):
+        self._default_allow = default_allow
+
+    async def check(self, tool_name: str, tool_input: dict[str, Any]) -> dict[str, Any]:
+        import builtins
+
+        # Format input summary
+        summary = ", ".join(f"{k}={v!r}" for k, v in list(tool_input.items())[:3])
+        if len(summary) > 120:
+            summary = summary[:117] + "..."
+
+        # Show prompt
+        sys.stderr.write(f"\n  Tool: {tool_name}\n")
+        if summary:
+            sys.stderr.write(f"  Input: {summary}\n")
+        sys.stderr.write("  Allow? [y/n] ")
+        sys.stderr.flush()
+
+        try:
+            response = builtins.input("").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            return {"allowed": False, "reason": "User cancelled"}
+
+        if response in ("y", "yes", ""):
+            return {"allowed": True}
+        return {"allowed": False, "reason": "User denied"}
+
+
+class RuleApprover:
+    """Checks tool calls against configurable deny rules.
+
+    Rules can deny by tool name, by input patterns, or by path restrictions.
+    """
+
+    def __init__(
+        self,
+        *,
+        denied_tools: set[str] | None = None,
+        denied_commands: set[str] | None = None,
+        allowed_paths: list[str] | None = None,
+    ):
+        self._denied_tools = denied_tools or set()
+        self._denied_commands = denied_commands or set()
+        self._allowed_paths = allowed_paths
+
+    async def check(self, tool_name: str, input: dict[str, Any]) -> dict[str, Any]:
+        # Check denied tools
+        if tool_name in self._denied_tools:
+            return {"allowed": False, "reason": f"Tool '{tool_name}' is denied by policy"}
+
+        # Check denied commands (for Bash tool)
+        if tool_name == "Bash":
+            cmd = input.get("command", "")
+            for denied in self._denied_commands:
+                if denied in cmd:
+                    return {"allowed": False, "reason": f"Command contains denied pattern: {denied}"}
+
+        # Check path restrictions
+        if self._allowed_paths is not None:
+            for key in ("path", "file_path"):
+                path = input.get(key)
+                if path and not any(path.startswith(p) for p in self._allowed_paths):
+                    return {"allowed": False, "reason": f"Path '{path}' outside allowed directories"}
+
+        return {"allowed": True}

duh/adapters/file_store.py

@@ -0,0 +1,151 @@
+"""FileStore adapter — JSONL-based session persistence.
+
+Stores each session as a .jsonl file under ~/.config/duh/sessions/.
+One JSON object per line = one message. Atomic writes via
+temp-file-then-rename for thread safety.
+
+    store = FileStore()
+    await store.save("abc-123", messages)
+    history = await store.load("abc-123")
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from duh.kernel.messages import Message
+
+
+def _default_base_dir() -> Path:
+    return Path.home() / ".config" / "duh" / "sessions"
+
+
+class FileStore:
+    """JSONL file-backed SessionStore implementation."""
+
+    def __init__(self, base_dir: Path | str | None = None):
+        self._base_dir = Path(base_dir) if base_dir else _default_base_dir()
+
+    def _session_path(self, session_id: str) -> Path:
+        return self._base_dir / f"{session_id}.jsonl"
+
+    def _ensure_dir(self) -> None:
+        self._base_dir.mkdir(parents=True, exist_ok=True)
+
+    # ------------------------------------------------------------------
+    # SessionStore protocol
+    # ------------------------------------------------------------------
+
+    async def save(self, session_id: str, messages: list[Any]) -> None:
+        """Append *new* messages to the session file.
+
+        Messages are serialised with ``dataclasses.asdict`` when they are
+        Message dataclass instances; plain dicts pass through as-is.
+        Writes are atomic: we write to a temporary file in the same
+        directory, then ``os.replace`` into the final path — so a crash
+        mid-write never corrupts existing data.
+        """
+        self._ensure_dir()
+        path = self._session_path(session_id)
+
+        # Read existing lines so we only *append* the delta.
+        existing_count = 0
+        if path.exists():
+            with open(path, "r", encoding="utf-8") as f:
+                existing_count = sum(1 for line in f if line.strip())
+
+        new_messages = messages[existing_count:]
+        if not new_messages:
+            return
+
+        lines: list[str] = []
+        for msg in new_messages:
+            if isinstance(msg, Message):
+                lines.append(json.dumps(asdict(msg), ensure_ascii=False))
+            else:
+                lines.append(json.dumps(msg, ensure_ascii=False))
+
+        # Atomic write: copy existing content + new lines → temp → rename.
+        fd, tmp_path = tempfile.mkstemp(
+            dir=str(self._base_dir), suffix=".tmp",
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as tmp:
+                # Copy existing content
+                if path.exists():
+                    with open(path, "r", encoding="utf-8") as orig:
+                        tmp.write(orig.read())
+                # Append new lines
+                for line in lines:
+                    tmp.write(line + "\n")
+            os.replace(tmp_path, str(path))
+        except BaseException:
+            # Clean up temp file on any error
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
+
+    async def load(self, session_id: str) -> list[dict[str, Any]] | None:
+        """Load messages for a session, returning dicts (not Message objects).
+
+        Returns ``None`` when the session file does not exist.
+        """
+        path = self._session_path(session_id)
+        if not path.exists():
+            return None
+
+        messages: list[dict[str, Any]] = []
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                stripped = line.strip()
+                if stripped:
+                    messages.append(json.loads(stripped))
+        return messages
+
+    async def list_sessions(self) -> list[dict[str, Any]]:
+        """Return metadata for every persisted session.
+
+        Each entry contains:
+        - ``session_id``
+        - ``created``   — ISO-8601 timestamp (file ctime)
+        - ``modified``  — ISO-8601 timestamp (file mtime)
+        - ``message_count``
+        """
+        if not self._base_dir.exists():
+            return []
+
+        sessions: list[dict[str, Any]] = []
+        for entry in sorted(self._base_dir.iterdir()):
+            if entry.suffix != ".jsonl" or not entry.is_file():
+                continue
+            stat = entry.stat()
+            with open(entry, "r", encoding="utf-8") as f:
+                count = sum(1 for line in f if line.strip())
+            sessions.append({
+                "session_id": entry.stem,
+                "created": datetime.fromtimestamp(
+                    stat.st_birthtime if hasattr(stat, "st_birthtime") else stat.st_ctime,
+                    tz=timezone.utc,
+                ).isoformat(),
+                "modified": datetime.fromtimestamp(
+                    stat.st_mtime, tz=timezone.utc,
+                ).isoformat(),
+                "message_count": count,
+            })
+        return sessions
+
+    async def delete(self, session_id: str) -> bool:
+        """Delete a session file. Returns True if it existed."""
+        path = self._session_path(session_id)
+        if path.exists():
+            path.unlink()
+            return True
+        return False