deep-agent-cli 0.1.0__py3-none-any.whl

agent/cli/clipboard.py

@@ -0,0 +1,224 @@
+"""Small, dependency-free system clipboard adapter for the TUI."""
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+from typing import Any
+
+
+class ClipboardError(RuntimeError):
+    """Raised when no usable system clipboard transport is available."""
+
+
+@dataclass(frozen=True)
+class ClipboardText:
+    text: str
+
+
+@dataclass(frozen=True)
+class ClipboardImage:
+    """Clipboard contains a bitmap; export is deliberately deferred."""
+
+
+@dataclass(frozen=True)
+class ClipboardFiles:
+    paths: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class ClipboardUnavailable:
+    reason: str
+
+
+ClipboardContent = ClipboardText | ClipboardImage | ClipboardFiles | ClipboardUnavailable
+
+
+class ClipboardAdapter:
+    """Inspect first, then export an image only after the caller's capability gate."""
+
+    def inspect(self) -> ClipboardContent:
+        powershell = _wsl_powershell()
+        if powershell is None:
+            return ClipboardUnavailable("Image clipboard paste is currently supported on WSL; use /image <path>")
+        script = r"""
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+Add-Type -AssemblyName System.Windows.Forms
+if ([Windows.Forms.Clipboard]::ContainsImage()) {
+  @{kind='image'} | ConvertTo-Json -Compress
+} elseif ([Windows.Forms.Clipboard]::ContainsFileDropList()) {
+  $items = @([Windows.Forms.Clipboard]::GetFileDropList() | ForEach-Object { [string]$_ })
+  @{kind='files'; paths=$items} | ConvertTo-Json -Compress
+} elseif ([Windows.Forms.Clipboard]::ContainsText()) {
+  @{kind='text'; text=[Windows.Forms.Clipboard]::GetText()} | ConvertTo-Json -Compress
+} else {
+  @{kind='unavailable'; reason='Clipboard has no text, image, or files'} | ConvertTo-Json -Compress
+}
+"""
+        try:
+            raw = _run_capture([powershell, "-NoProfile", "-STA", "-Command", script], timeout=5)
+            payload = json.loads(raw)
+        except (ClipboardError, json.JSONDecodeError) as exc:
+            return ClipboardUnavailable(str(exc))
+        kind = payload.get("kind")
+        if kind == "image":
+            return ClipboardImage()
+        if kind == "files":
+            paths = payload.get("paths") or []
+            if isinstance(paths, str):
+                paths = [paths]
+            return ClipboardFiles(tuple(str(path) for path in paths))
+        if kind == "text":
+            return ClipboardText(str(payload.get("text") or ""))
+        return ClipboardUnavailable(str(payload.get("reason") or "Clipboard content is unavailable"))
+
+    def export_image(self) -> Path:
+        powershell = _wsl_powershell()
+        if powershell is None:
+            raise ClipboardError("WSL PowerShell clipboard is unavailable")
+        fd, name = tempfile.mkstemp(prefix="deep-agent-clipboard-", suffix=".png")
+        os.close(fd)
+        path = Path(name)
+        path.unlink(missing_ok=True)
+        windows_path = _wslpath(path, to_windows=True)
+        escaped = windows_path.replace("'", "''")
+        script = rf"""
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$image = [Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $image) {{ throw 'Clipboard image is no longer available' }}
+try {{ $image.Save('{escaped}', [Drawing.Imaging.ImageFormat]::Png) }} finally {{ $image.Dispose() }}
+"""
+        try:
+            _run_capture([powershell, "-NoProfile", "-STA", "-Command", script], timeout=10)
+            if not path.is_file():
+                raise ClipboardError("PowerShell did not export the clipboard image")
+            return path
+        except Exception:
+            path.unlink(missing_ok=True)
+            raise
+
+
+def copy_to_clipboard(text: str, *, output: Any | None = None) -> str:
+    """Copy text and return the backend name used.
+
+    WSL's ``clip.exe`` expects UTF-16LE on stdin. Other native helpers accept
+    UTF-8. OSC 52 is the final fallback for terminals without a local helper.
+    """
+    if not text:
+        raise ClipboardError("Nothing selected")
+
+    clip = _wsl_clipboard()
+    if clip is not None:
+        _run([clip], text.encode("utf-16le"))
+        return "clip.exe"
+
+    candidates = (
+        (["pbcopy"], "pbcopy"),
+        (["wl-copy"], "wl-copy"),
+        (["xclip", "-selection", "clipboard"], "xclip"),
+        (["xsel", "--clipboard", "--input"], "xsel"),
+    )
+    for command, name in candidates:
+        executable = shutil.which(command[0])
+        if executable is None:
+            continue
+        _run([executable, *command[1:]], text.encode("utf-8"))
+        return name
+
+    if output is not None and hasattr(output, "write_raw"):
+        try:
+            encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+            output.write_raw(f"\x1b]52;c;{encoded}\x07")
+            output.flush()
+            return "OSC 52"
+        except (OSError, ValueError) as exc:
+            raise ClipboardError(f"OSC 52 clipboard failed: {exc}") from exc
+
+    raise ClipboardError("No system clipboard helper is available")
+
+
+def _wsl_clipboard() -> str | None:
+    if not _is_wsl():
+        return None
+    executable = shutil.which("clip.exe")
+    if executable:
+        return executable
+    fallback = Path("/mnt/c/Windows/System32/clip.exe")
+    return str(fallback) if fallback.is_file() else None
+
+
+def _wsl_powershell() -> str | None:
+    if not _is_wsl():
+        return None
+    executable = shutil.which("powershell.exe")
+    if executable:
+        return executable
+    fallback = Path("/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe")
+    return str(fallback) if fallback.is_file() else None
+
+
+def windows_path_to_wsl(value: str) -> Path:
+    if not _is_wsl() or not re_windows_path(value):
+        return Path(value).expanduser()
+    return Path(_wslpath(Path(value), to_windows=False))
+
+
+def re_windows_path(value: str) -> bool:
+    return len(value) >= 3 and value[1] == ":" and value[2] in {"\\", "/"}
+
+
+def _wslpath(path: Path, *, to_windows: bool) -> str:
+    command = ["wslpath", "-w" if to_windows else "-u", str(path)]
+    return _run_capture(command, timeout=3).strip()
+
+
+def _is_wsl() -> bool:
+    if os.environ.get("WSL_DISTRO_NAME") or os.environ.get("WSL_INTEROP"):
+        return True
+    try:
+        return "microsoft" in Path("/proc/sys/kernel/osrelease").read_text(encoding="utf-8").lower()
+    except OSError:
+        return False
+
+
+def _run(command: list[str], payload: bytes) -> None:
+    try:
+        subprocess.run(
+            command,
+            input=payload,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            check=True,
+            timeout=2,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        detail = getattr(exc, "stderr", b"")
+        if isinstance(detail, bytes):
+            detail = detail.decode("utf-8", errors="replace").strip()
+        suffix = f": {detail}" if detail else ""
+        raise ClipboardError(f"Clipboard command failed{suffix}") from exc
+
+
+def _run_capture(command: list[str], *, timeout: int) -> str:
+    try:
+        result = subprocess.run(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=True,
+            timeout=timeout,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        detail = getattr(exc, "stderr", b"")
+        if isinstance(detail, bytes):
+            detail = detail.decode("utf-8", errors="replace").strip()
+        raise ClipboardError(f"Clipboard command failed{f': {detail}' if detail else ''}") from exc
+    return result.stdout.decode("utf-8", errors="replace").lstrip("\ufeff").strip()

agent/cli/commands.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+if TYPE_CHECKING:
+    from agent.cli.app import CliApplication
+
+
+CommandHandler = Callable[["CliApplication", str], Awaitable[None]]
+
+
+@dataclass(frozen=True)
+class Command:
+    name: str
+    description: str
+    handler: CommandHandler
+
+
+def command_table() -> tuple[Command, ...]:
+    return (
+        Command("help", "Show commands and keyboard shortcuts", _help),
+        Command("clear", "Clear the visible transcript", _clear),
+        Command("status", "Show runtime and sandbox status", _status),
+        Command("pause", "Pause at the next model safe point", _pause),
+        Command("new", "Start a new persistent session thread", _new),
+        Command("session", "Show current session information", _session),
+        Command("resume", "List sessions with content (/resume or /resume <id-prefix>)", _resume),
+        Command("model", "Select a model (/model or /model <id-prefix>)", _model),
+        Command("compact", "Summarize older conversation when context permits", _compact),
+        Command("image", "Attach an image (/image <path|clipboard>, /image, /image clear)", _image),
+        Command("attachments", "Attachment maintenance (/attachments cleanup)", _attachments),
+        Command(
+            "permission",
+            "Tool approval: ask (every execute) or allow (SANDBOXED auto-approve + sandbox network open, HIGH RISK)",
+            _permission,
+        ),
+        Command("quit", "Exit DeepAgent", _quit),
+        Command("exit", "Exit DeepAgent", _quit),
+    )
+
+
+async def _help(app: "CliApplication", _arg: str) -> None:
+    app.show_help()
+
+
+async def _clear(app: "CliApplication", _arg: str) -> None:
+    app.state.clear()
+    app.set_status("Transcript cleared; agent context was preserved")
+
+
+async def _status(app: "CliApplication", _arg: str) -> None:
+    app.show_status()
+
+
+async def _pause(app: "CliApplication", _arg: str) -> None:
+    app.runner.request_pause()
+    app.set_status("Pause requested for the next model safe point")
+
+
+async def _new(app: "CliApplication", _arg: str) -> None:
+    app.new_session()
+
+
+async def _session(app: "CliApplication", _arg: str) -> None:
+    app.show_session()
+
+
+async def _resume(app: "CliApplication", arg: str) -> None:
+    await app.resume_session(arg)
+
+
+async def _model(app: "CliApplication", arg: str) -> None:
+    await app.select_model(arg)
+
+
+async def _compact(app: "CliApplication", arg: str) -> None:
+    await app.compact_command(arg)
+
+
+async def _image(app: "CliApplication", arg: str) -> None:
+    await app.image_command(arg)
+
+
+async def _attachments(app: "CliApplication", arg: str) -> None:
+    await app.attachments_command(arg)
+
+
+async def _permission(app: "CliApplication", arg: str) -> None:
+    await app.select_permission(arg)
+
+
+async def _quit(app: "CliApplication", _arg: str) -> None:
+    app.exit()

agent/cli/gitinfo.py

@@ -0,0 +1,84 @@
+"""Workspace git summary for the status footer.
+
+The footer repaints several times a second, so git is probed on a timer in the
+background and the UI only ever reads the last known summary.
+"""
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+REFRESH_SECONDS = 5.0
+TIMEOUT_SECONDS = 2.0
+
+_NO_BRANCH_PREFIX = "No commits yet on "
+
+
+@dataclass(frozen=True)
+class GitSummary:
+    """Branch name plus changed-path count; empty when this is not a repository."""
+
+    branch: str = ""
+    changed: int = 0
+    available: bool = False
+
+    def label(self) -> str:
+        if not self.available:
+            return ""
+        state = f"{self.changed} changed" if self.changed else "clean"
+        return f"⎇ {self.branch} · {state}"
+
+
+def parse_status(output: str) -> GitSummary:
+    """Parse `git status --porcelain --branch` output."""
+    lines = output.splitlines()
+    branch = ""
+    if lines and lines[0].startswith("## "):
+        head = lines[0][3:].strip()
+        lines = lines[1:]
+        if head.startswith(_NO_BRANCH_PREFIX):
+            branch = head.removeprefix(_NO_BRANCH_PREFIX).strip()
+        elif "no branch" in head or head.startswith("HEAD"):
+            branch = "detached"
+        else:
+            branch = head.split("...", 1)[0].strip()
+    return GitSummary(
+        branch=branch or "unknown",
+        changed=sum(1 for line in lines if line.strip()),
+        available=True,
+    )
+
+
+class GitProbe:
+    """Background `git status` whose last result is safe to read from a render pass."""
+
+    def __init__(self, workspace: Path) -> None:
+        self.workspace = workspace
+        self.summary = GitSummary()
+
+    async def refresh(self) -> GitSummary:
+        process: asyncio.subprocess.Process | None = None
+        try:
+            process = await asyncio.create_subprocess_exec(
+                "git", "status", "--porcelain", "--branch",
+                cwd=str(self.workspace),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            stdout, _ = await asyncio.wait_for(process.communicate(), timeout=TIMEOUT_SECONDS)
+            self.summary = (
+                parse_status(stdout.decode("utf-8", "replace"))
+                if process.returncode == 0 else GitSummary()
+            )
+        except (OSError, ValueError, TimeoutError, subprocess.SubprocessError):
+            self.summary = GitSummary()
+        finally:
+            if process is not None and process.returncode is None:
+                try:
+                    process.kill()
+                except ProcessLookupError:
+                    pass
+                await process.wait()
+        return self.summary

agent/cli/input.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+DEFAULT_BINDINGS: dict[str, list[str]] = {
+    "submit": ["enter"],
+    "newline": ["c-j"],
+    "follow_up": ["alt+enter"],
+    "interrupt": ["escape"],
+    "clear_or_exit": ["c-c"],
+    "exit": ["c-d"],
+    "tools_expand": ["c-o"],
+    "review_diff": ["c-r"],
+    "reopen_interaction": ["f2"],
+    "thinking_toggle": ["c-t"],
+    "dequeue": ["alt+up"],
+    # Windows Terminal may reserve Ctrl+V for terminal paste. Alt+V is the
+    # reliable application-level image clipboard fallback.
+    "image_paste": ["ctrl+v", "alt+v"],
+    # prompt_toolkit has no ControlShift+letter; Alt+P is the backward cycle fallback.
+    "model_cycle_forward": ["ctrl+p"],
+    "model_cycle_backward": ["alt+p"],
+}
+
+
+@dataclass
+class Keymap:
+    bindings: dict[str, list[str]] = field(default_factory=lambda: {
+        name: list(keys) for name, keys in DEFAULT_BINDINGS.items()
+    })
+    warning: str = ""
+
+    @classmethod
+    def load(cls, path: Path | None) -> "Keymap":
+        result = cls()
+        if path is None or not path.is_file():
+            return result
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            for action, value in raw.items():
+                if action not in result.bindings:
+                    continue
+                keys = [value] if isinstance(value, str) else value
+                if isinstance(keys, list) and keys and all(isinstance(item, str) for item in keys):
+                    result.bindings[action] = keys
+        except (OSError, ValueError, TypeError) as exc:
+            result.warning = f"Could not load keybindings: {exc}"
+        return result
+
+    def sequences(self, action: str) -> list[tuple[str, ...]]:
+        return [_prompt_toolkit_keys(value) for value in self.bindings[action]]
+
+
+def _prompt_toolkit_keys(value: str) -> tuple[str, ...]:
+    keys = value.strip().lower()
+    if keys.startswith("alt+"):
+        return ("escape", keys.removeprefix("alt+"))
+    if keys.startswith("ctrl+"):
+        return (f"c-{keys.removeprefix('ctrl+')}",)
+    if keys == "shift+tab":
+        return ("s-tab",)
+    return tuple(part for part in keys.split() if part)

agent/cli/interactions.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from rich.console import Group
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+
+
+@dataclass
+class InteractionController:
+    kind: str
+    title: str
+    question: str
+    fields: list[dict[str, Any]]
+    interaction_id: str = ""
+    reason: str = ""
+    recommendation: dict[str, Any] = field(default_factory=dict)
+    impact: list[str] = field(default_factory=list)
+    index: int = 0
+    option_index: int = 0
+    values: dict[str, Any] = field(default_factory=dict)
+    error: str = ""
+    tool_call_ids: list[str] = field(default_factory=list)
+    calls: list[dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def human(cls, payload: dict[str, Any]) -> "InteractionController":
+        fields = payload.get("fields") if isinstance(payload.get("fields"), list) else []
+        if not fields:
+            fields = [{"id": "text", "type": "textarea", "label": "Reply", "required": True, "options": []}]
+        fields = [dict(field) for field in fields]
+        for field in fields:
+            if field.get("type") == "boolean" and not field.get("options"):
+                field["options"] = [
+                    {"value": False, "label": "No", "description": ""},
+                    {"value": True, "label": "Yes", "description": ""},
+                ]
+        return cls(
+            kind="human",
+            title=str(payload.get("title") or "Input required"),
+            question=str(payload.get("question") or "Please provide the requested information."),
+            reason=str(payload.get("reason") or ""),
+            fields=fields,
+            interaction_id=str(payload.get("interactionId") or ""),
+            recommendation=payload.get("recommendation") if isinstance(payload.get("recommendation"), dict) else {},
+            impact=[str(item) for item in payload.get("impact", [])],
+        )
+
+    @classmethod
+    def approval(cls, calls: list[dict[str, Any]]) -> "InteractionController":
+        from agent.network import network_requested
+
+        declared: list[str] = []
+        for call in calls:
+            name = str(call.get("name") or "tool")
+            args = call.get("args") if isinstance(call.get("args"), dict) else {}
+            if name == "execute" and network_requested(args):
+                declared.append("HOST NETWORK (internet, localhost, LAN)")
+            elif name in {"write_file", "edit_file", "delete"}:
+                declared.append(name.upper())
+        caps = ", ".join(dict.fromkeys(declared)) if declared else "declared capabilities"
+        return cls(
+            kind="approval",
+            title="Approve tool call?",
+            question=f"Approve runs this call with its declared capabilities ({caps}).",
+            fields=[{
+                "id": "approved", "type": "single_select", "label": "Decision", "required": True,
+                "options": [
+                    {"value": "reject", "label": "Reject", "description": "Deny this tool call"},
+                    {"value": "approve", "label": "Run", "description": "Approve and execute"},
+                ],
+            }],
+            tool_call_ids=[str(call.get("toolCallId") or "") for call in calls if call.get("toolCallId")],
+            calls=list(calls),
+        )
+
+    @classmethod
+    def pause(cls) -> "InteractionController":
+        return cls(
+            kind="pause",
+            title="Paused",
+            question="Continue the agent run?",
+            fields=[{
+                "id": "continue", "type": "single_select", "label": "Decision", "required": True,
+                "options": [
+                    {"value": "stay", "label": "No", "description": ""},
+                    {"value": "continue", "label": "Yes", "description": ""},
+                ],
+            }],
+        )
+
+    @property
+    def current(self) -> dict[str, Any]:
+        return self.fields[min(self.index, len(self.fields) - 1)]
+
+    @property
+    def accepts_text(self) -> bool:
+        return str(self.current.get("type")) in {"text", "textarea"}
+
+    def move(self, delta: int) -> None:
+        options = self.current.get("options") or []
+        if options:
+            self.option_index = (self.option_index + delta) % len(options)
+
+    def toggle(self) -> None:
+        if self.current.get("type") != "multi_select":
+            return
+        options = self.current.get("options") or []
+        if not options:
+            return
+        field_id = str(self.current.get("id") or "field")
+        selected = list(self.values.get(field_id) or [])
+        value = str(options[self.option_index].get("value"))
+        selected.remove(value) if value in selected else selected.append(value)
+        self.values[field_id] = selected
+
+    def accept(self, text: str = "") -> bool:
+        field = self.current
+        field_id = str(field.get("id") or f"field_{self.index}")
+        field_type = str(field.get("type") or "text")
+        options = field.get("options") or []
+        if field_type in {"text", "textarea"}:
+            value: Any = text.strip()
+        elif field_type == "multi_select":
+            value = self.values.get(field_id) or []
+        elif options:
+            raw_value = options[self.option_index].get("value")
+            value = raw_value if field_type == "boolean" else str(raw_value or "")
+        else:
+            value = text.strip()
+        if field.get("required") and (value == "" or value == []):
+            self.error = "This field is required."
+            return False
+        self.values[field_id] = value
+        self.error = ""
+        if self.index + 1 < len(self.fields):
+            self.index += 1
+            self.option_index = 0
+            return False
+        return True
+
+    def render(self) -> Group:
+        parts: list[Any] = [Text(self.title, style="bold bright_cyan")]
+        if self.reason:
+            parts.append(Text(self.reason, style="dim"))
+        if self.question:
+            parts.append(Text(self.question) if self.kind == "approval" else Markdown(self.question))
+        if self.recommendation:
+            value = self.recommendation.get("value") or ""
+            why = self.recommendation.get("reason") or ""
+            parts.append(Text(f"Recommended: {value} {why}".strip(), style="cyan"))
+        if self.impact:
+            parts.append(Text("Impact:\n" + "\n".join(f"• {item}" for item in self.impact), style="yellow"))
+        field = self.current
+        parts.append(Text(f"{self.index + 1}/{len(self.fields)}  {field.get('label') or field.get('id')}", style="bold"))
+        options = field.get("options") or []
+        selected = self.values.get(str(field.get("id") or "")) or []
+        for idx, option in enumerate(options):
+            pointer = "→" if idx == self.option_index else " "
+            mark = "[x]" if option.get("value") in selected else "[ ]" if field.get("type") == "multi_select" else ""
+            description = option.get("description") or ""
+            style = "bold cyan" if idx == self.option_index else ""
+            label = f"{pointer} {mark} {option.get('label')}  {description}".rstrip()
+            if right_label := option.get("right_label"):
+                row = Table.grid(expand=True, padding=(0, 1))
+                row.add_column(ratio=1, no_wrap=True, overflow="ellipsis")
+                row.add_column(width=len(str(right_label)), justify="right", no_wrap=True)
+                row.add_row(Text(label, style=style), Text(str(right_label), style=style))
+                parts.append(row)
+            else:
+                parts.append(Text(label, style=style))
+        if self.error:
+            parts.append(Text(self.error, style="red"))
+        hint = (
+            "↑↓ select  Enter confirm  Esc back"
+            if self.kind == "model" and self.values.get("source")
+            else "↑↓ select  Enter confirm  Esc cancel · F2 to reopen"
+            if self.kind in {"approval", "human", "pause"} and options
+            else "↑↓ select  Enter confirm  Esc cancel"
+            if options
+            else "Enter submit  Ctrl+J newline  Esc cancel"
+        )
+        parts.append(Text(hint, style="dim"))
+        return Group(*parts)