copper-pilot-cli 0.1.1__py3-none-any.whl

copper_pilot_cli/__init__.py

@@ -0,0 +1,37 @@
+"""CopperPilot hosted agent, terminal client, and LangChain adapters."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from copper_pilot_cli._version import __version__
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+__all__ = [
+    "__version__",
+    "cli_main",  # noqa: F822  # resolved lazily by __getattr__
+]
+
+
+def __getattr__(name: str) -> Callable[[], None]:
+    """Lazy import for `cli_main` to avoid loading `main.py` at package import.
+
+    `copper_main.py` pulls in Textual and startup machinery
+    that isn't needed when submodules like `config` or `widgets` are
+    imported directly.
+
+    Returns:
+        The requested callable.
+
+    Raises:
+        AttributeError: If *name* is not a lazily-provided attribute.
+
+    """
+    if name == "cli_main":
+        from copper_pilot_cli.copper_main import cli_main
+
+        return cli_main
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)

copper_pilot_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the CLI as: `python -m copper_pilot_cli`."""
+
+from copper_pilot_cli import cli_main
+
+if __name__ == "__main__":
+    cli_main()

copper_pilot_cli/_upstream/dcode_0_1_69/PROVENANCE.json

@@ -0,0 +1,46 @@
+{
+  "project": "Deep Agents Code",
+  "repository": "https://github.com/langchain-ai/deepagents",
+  "package_version": "0.1.69",
+  "revision": "1d3232c0852c47af09119edea10eeec887e4f0da",
+  "license": "MIT",
+  "files": [
+    {
+      "local_path": "diff_utils.py",
+      "upstream_path": "libs/code/deepagents_code/diff_utils.py",
+      "sha256": "3085c4f249a22b06244c34e5f115ae005cb56456eecefd7f34c92d47861e8f8c",
+      "patch_status": "unchanged"
+    }
+  ],
+  "adapted_files": [
+    {
+      "local_path": "../../clipboard.py",
+      "upstream_paths": [
+        "libs/code/deepagents_code/clipboard.py",
+        "libs/code/deepagents_code/app.py"
+      ]
+    },
+    {
+      "local_path": "../../textual_patches.py",
+      "upstream_paths": [
+        "libs/code/deepagents_code/_textual_patches.py"
+      ]
+    },
+    {
+      "local_path": "../../copper_widgets.py",
+      "upstream_paths": [
+        "libs/code/deepagents_code/tui/widgets/chat_input.py",
+        "libs/code/deepagents_code/tui/widgets/autocomplete.py"
+      ]
+    }
+  ],
+  "intentional_differences": [
+    "CopperPilot branding and hosted authentication",
+    "CopperPilot hosted WebSocket transport instead of a local provider runtime",
+    "No LangSmith, MCP, plugins, sandboxes, local model setup, or computer use",
+    "CLI-owned deterministic Auto policy with independent normal and dangerous shell settings",
+    "Provider context-window metrics are omitted because the hosted protocol has no truthful values",
+    "Successful tool calls use dcode-style compact groups driven by CopperPilot hosted events",
+    "Uninterrupted successful reasoning and tools collapse with CopperPilot desktop Worked-for timing"
+  ]
+}

copper_pilot_cli/_upstream/dcode_0_1_69/diff_utils.py

@@ -0,0 +1,222 @@
+r"""Shared unified-diff helpers.
+
+Every diff passing through this module is `"\n"`-joined from lines that came
+from `splitlines()` or `split("\n")`, so no element can contain a line boundary.
+That is what makes `split_diff_lines` the exact inverse and `splitlines()` wrong
+here — see its docstring for what breaks. Check any helper added to this module,
+and any new producer of a diff it reads, against that invariant.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Final
+
+HUNK_RE: Final[re.Pattern[str]] = re.compile(r"@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))?")
+"""Matches a hunk header.
+
+Captures, in order: old start line, old line count, new start line, new line
+count. Either count is absent for a single-line range, where it defaults to 1.
+"""
+
+
+DIFF_TRUNCATION_MARKER: Final[str] = "..."
+"""Stand-in line marking where a diff body was clipped for display.
+
+Written by `compute_unified_diff` and rendered as a `truncated` row. It is also
+the signal that any counts recomputed from the body would be short — see
+`DiffMessage._recount`, which returns `None` rather than a known-low number.
+
+Match it with `is_truncation_marker` rather than by hand: the renderer and the
+recount must agree, or a body that renders "diff truncated" is also counted as
+if it were complete.
+"""
+
+
+def is_truncation_marker(line: str) -> bool:
+    """Return whether a diff line is the truncation marker.
+
+    One predicate for both readers, which previously disagreed: the renderer
+    stripped, the recount compared exactly.
+
+    Exact, deliberately. `compute_unified_diff` writes the marker bare, while
+    every real diff line carries a `+`, `-`, or space prefix — so an exact match
+    cannot collide with file content, and a source line whose own text is `...`
+    arrives here as `" ..."` and stays a context row. Stripping would classify
+    that line as a clipped body and suppress the change counts for a diff that
+    is complete.
+
+    Args:
+        line: A single unified-diff line.
+
+    Returns:
+        Whether the line marks a clipped body.
+    """
+    return line == DIFF_TRUNCATION_MARKER
+
+
+@dataclass(frozen=True, kw_only=True)
+class DiffStats:
+    """Line counts for a change, named so the pair cannot be swapped silently.
+
+    Keyword-only and frozen so that claim holds at construction as well as in
+    transit: a positional pair is exactly the transposition this type exists to
+    rule out, and the counts are read long after they are computed.
+
+    Attributes:
+        additions: Added change lines, excluding file headers, counted before
+            any truncation of the body for display.
+        deletions: Removed change lines, on the same terms.
+    """
+
+    additions: int
+    deletions: int
+
+    def __post_init__(self) -> None:
+        """Reject negative counts.
+
+        Both in-repo producers derive from `difflib`, so this only guards direct
+        construction — but the type is public and reaches a delete prompt, where
+        the number gates destroying a file.
+
+        Raises:
+            ValueError: If either count is negative.
+        """
+        if self.additions < 0 or self.deletions < 0:
+            msg = (
+                f"DiffStats counts cannot be negative, got additions="
+                f"{self.additions}, deletions={self.deletions}"
+            )
+            raise ValueError(msg)
+
+
+def split_diff_lines(diff: str) -> list[str]:
+    r"""Split a unified diff back into the lines it was assembled from.
+
+    Deliberately not `splitlines()`. Every diff reaching this function is
+    `"\n"`-joined from lines that themselves came from `splitlines()` or
+    `split("\n")`, so no element can contain a line boundary and `"\n"` is the
+    exact inverse. `splitlines()` also breaks on `\r`, `\v`, `\f`, U+2028,
+    U+2029 and U+0085, which splits a single diff line into fragments. The tail
+    fragment carries no `+`/`-` marker, so it would render as an unmarked note —
+    on the approval prompt that means changed content shown as neutral metadata.
+
+    Check any new producer against that invariant rather than against a list of
+    the current ones.
+
+    Args:
+        diff: Unified diff string.
+
+    Returns:
+        The diff's lines, without a trailing empty entry for a terminating
+        newline.
+    """
+    lines = diff.split("\n")
+    if lines and not lines[-1]:
+        lines.pop()
+    return lines
+
+
+def file_header_indexes(lines: list[str]) -> set[int]:
+    """Locate paired file headers immediately preceding a hunk.
+
+    A `---`/`+++` pair is only a file header when it appears *outside* a hunk
+    body — a diff of a file that itself contains such lines would otherwise
+    have its content mistaken for metadata. That is why this walks the hunks'
+    declared old/new line budgets instead of just matching on the prefix.
+
+    Args:
+        lines: Unified-diff lines. Handles multi-file diffs, where headers
+            recur between hunks.
+
+    Returns:
+        Indexes of file-header lines.
+    """
+    indexes: set[int] = set()
+    old_remaining = new_remaining = 0
+    inside_hunk = False
+    for index, line in enumerate(lines):
+        if match := HUNK_RE.match(line):
+            old_remaining = int(match.group(2) or 1)
+            new_remaining = int(match.group(4) or 1)
+            inside_hunk = old_remaining > 0 or new_remaining > 0
+            continue
+        if inside_hunk:
+            if _opens_file_header(lines, index):
+                # The budget says this hunk is still running, but a full
+                # `---`/`+++`/`@@` sequence starts here — so the budget
+                # over-declared and the next file has begun. Without this the
+                # `--- a/y.py` is consumed as a deletion, the following headers
+                # render as source rows, and the change counts include them.
+                # The three-line shape is what makes this safe: a removed line
+                # can read `--- something`, but not while the two lines after
+                # it also form a header pair and a hunk header.
+                inside_hunk = False
+            elif line.startswith("\\"):
+                # "" annotates the line before it and
+                # belongs to neither budget.
+                continue
+            elif line.startswith("-"):
+                old_remaining -= 1
+            elif line.startswith("+"):
+                new_remaining -= 1
+            elif line.startswith(" "):
+                old_remaining -= 1
+                new_remaining -= 1
+            else:
+                # Not a hunk body line: the declared budget over-counts, or the
+                # producer is not `difflib`. End the hunk here and re-read this
+                # line as metadata below. Staying inside would consume the rest
+                # of the diff — including a following file's `---`/`+++` pair —
+                # as body, which counts those headers as a change and renders
+                # them as source rows.
+                inside_hunk = False
+            if inside_hunk:
+                # Only lines that consumed budget skip the header check. A
+                # removed line may legitimately read `--- something`, and
+                # treating it as metadata is the misreading this walk prevents.
+                inside_hunk = old_remaining > 0 or new_remaining > 0
+                continue
+        if _opens_file_header(lines, index):
+            indexes.update((index, index + 1))
+    return indexes
+
+
+def _opens_file_header(lines: list[str], index: int) -> bool:
+    """Whether a file-header pair immediately preceding a hunk starts here.
+
+    Args:
+        lines: Unified-diff lines.
+        index: Position of the candidate `---` line.
+
+    Returns:
+        Whether `lines[index:index + 3]` is `---`, `+++`, and a hunk header.
+    """
+    return (
+        index + 2 < len(lines)
+        and lines[index].startswith("--- ")
+        and lines[index + 1].startswith("+++ ")
+        and HUNK_RE.match(lines[index + 2]) is not None
+    )
+
+
+def count_diff_change_lines(lines: list[str]) -> DiffStats:
+    """Count added and removed lines in unified-diff lines.
+
+    Args:
+        lines: Unified-diff lines.
+
+    Returns:
+        Additions and deletions, excluding file headers.
+    """
+    headers = file_header_indexes(lines)
+    additions = deletions = 0
+    for index, line in enumerate(lines):
+        if index in headers:
+            continue
+        if line.startswith("+"):
+            additions += 1
+        elif line.startswith("-"):
+            deletions += 1
+    return DiffStats(additions=additions, deletions=deletions)

copper_pilot_cli/_version.py

@@ -0,0 +1,32 @@
+"""CopperPilot CLI version and update endpoints."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+try:
+    __version__ = version("copper-pilot-cli")
+except PackageNotFoundError:
+    __version__ = (
+        Path(__file__).resolve().parents[2].joinpath("VERSION").read_text(encoding="utf-8").strip()
+    )
+
+DOCS_URL = "https://copperpilot.ai"
+"""URL for CopperPilot documentation."""
+
+PYPI_URL = "https://pypi.org/pypi/copper-pilot-cli/json"
+"""PyPI JSON API endpoint for version checks."""
+
+SDK_PYPI_URL = "https://pypi.org/pypi/deepagents/json"
+"""PyPI JSON API endpoint for reading `deepagents` SDK release metadata.
+
+The CLI only reads release-age metadata from this endpoint; it never
+performs SDK update checks.
+"""
+
+CHANGELOG_URL = "https://github.com/CopperPilot/copper-pilot-cli/releases"
+"""URL for the full changelog."""
+
+USER_AGENT = f"copper-pilot-cli/{__version__} update-check"
+"""User-Agent header sent with PyPI requests."""

copper_pilot_cli/clipboard.py

@@ -0,0 +1,107 @@
+"""Clipboard helpers adapted from Deep Agents Code 0.1.69."""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pyperclip
+from textual.dom import NoScreen
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual.app import App
+    from textual.screen import Screen
+
+logger = logging.getLogger(__name__)
+
+_PREVIEW_MAX_LENGTH = 40
+
+
+def _copy_osc52(text: str) -> None:
+    """Copy text with OSC 52 for remote terminals and tmux."""
+    encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
+    sequence = f"\033]52;c;{encoded}\a"
+    if os.environ.get("TMUX"):
+        sequence = f"\033Ptmux;\033{sequence}\033\\"
+    with Path("/dev/tty").open("w", encoding="utf-8") as tty:
+        tty.write(sequence)
+        tty.flush()
+
+
+def _shorten_preview(texts: list[str]) -> str:
+    dense_text = "↵".join(texts).replace("\n", "↵")
+    if len(dense_text) > _PREVIEW_MAX_LENGTH:
+        return f"{dense_text[: _PREVIEW_MAX_LENGTH - 1]}…"
+    return dense_text
+
+
+def copy_text_to_clipboard(app: App[object], text: str) -> tuple[bool, str | None]:
+    """Try the same clipboard backends as dcode, in reliability order."""
+    methods: list[Callable[[str], object]] = [
+        pyperclip.copy,
+        app.copy_to_clipboard,
+        _copy_osc52,
+    ]
+    last_error: str | None = None
+    for copy in methods:
+        try:
+            copy(text)
+        except (OSError, RuntimeError, TypeError, ValueError) as exc:
+            last_error = str(exc) or type(exc).__name__
+            logger.debug(
+                "Clipboard method %s failed: %s",
+                getattr(copy, "__name__", repr(copy)),
+                exc,
+                exc_info=True,
+            )
+        else:
+            return True, None
+    return False, last_error
+
+
+def copy_selection_to_clipboard(app: App[object], *, screen: Screen[object]) -> None:
+    """Copy all non-empty selections owned by the screen that received mouse-up."""
+    selected_texts: list[str] = []
+    for widget in screen.query("*"):
+        if not getattr(widget, "is_attached", False):
+            continue
+        try:
+            selection = widget.text_selection
+        except (NoScreen, AttributeError) as exc:
+            logger.debug("Skipping detached selection widget: %s", exc)
+            continue
+        if not selection:
+            continue
+        try:
+            result = widget.get_selection(selection)
+        except (AttributeError, TypeError, ValueError, IndexError) as exc:
+            logger.debug("Unable to extract widget selection: %s", exc, exc_info=True)
+            continue
+        if result:
+            selected_text, _ = result
+            if selected_text.strip():
+                selected_texts.append(selected_text)
+
+    if not selected_texts:
+        return
+
+    success, _ = copy_text_to_clipboard(app, "\n".join(selected_texts))
+    if success:
+        app.notify(
+            f'"{_shorten_preview(selected_texts)}" copied',
+            severity="information",
+            timeout=2,
+            markup=False,
+        )
+    else:
+        app.notify(
+            "Failed to copy - no clipboard method available",
+            severity="warning",
+            timeout=3,
+            markup=False,
+        )

copper_pilot_cli/copper_api.py

@@ -0,0 +1,24 @@
+"""Small authenticated HTTP surface used by the CopperPilot TUI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from copper_pilot_cli.copper_auth import DeviceCredential
+
+
+async def token_limits(credential: DeviceCredential) -> dict[str, Any]:
+    """Fetch the account's authoritative token/usage limits."""
+    async with httpx.AsyncClient(timeout=15) as client:
+        response = await client.post(
+            f"{credential.base_url}/api/copperpilot/analyze/token_limits",
+            headers={
+                "Authorization": f"Bearer {credential.api_key}",
+                "X-CopperPilot-Fingerprint": credential.fingerprint,
+            },
+        )
+        response.raise_for_status()
+        value = response.json()
+    return value if isinstance(value, dict) else {}