batrachian-toad 0.5.22__py3-none-any.whl

toad/path_complete.py

@@ -0,0 +1,145 @@
+import asyncio
+import os
+from pathlib import Path
+from typing import Literal, Sequence
+
+
+def longest_common_prefix(strings: list[str]) -> str:
+    """
+    Find the longest common prefix among a list of strings.
+
+    Arguments:
+        strings: List of strings
+
+    Returns:
+        The longest common prefix string
+    """
+    if not strings:
+        return ""
+
+    # Start with the first string as reference
+    prefix: str = strings[0]
+
+    # Compare with each subsequent string
+    for current_string in strings[1:]:
+        # Reduce prefix until it matches the start of current string
+        while not current_string.startswith(prefix):
+            prefix = prefix[:-1]
+            if not prefix:
+                return ""
+
+    return prefix
+
+
+class DirectoryReadTask:
+    """A task to read a directory."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.done_event = asyncio.Event()
+        self.directory_listing: list[Path] = []
+        self._task: asyncio.Task | None = None
+
+    def read(self) -> None:
+        # TODO: Should this be cancellable, or have a maximum number of paths for the case of very large directories?
+        for path in self.path.iterdir():
+            self.directory_listing.append(path)
+
+    def start(self) -> None:
+        asyncio.create_task(self.run(), name=f"DirectoryReadTask({str(self.path)!r})")
+
+    async def run(self):
+        await asyncio.to_thread(self.read)
+        self.done_event.set()
+
+    async def wait(self) -> list[Path]:
+        await self.done_event.wait()
+        return self.directory_listing
+
+
+class PathComplete:
+    """Auto completes paths."""
+
+    def __init__(self) -> None:
+        self.read_tasks: dict[Path, DirectoryReadTask] = {}
+        self.directory_listings: dict[Path, list[Path]] = {}
+
+    async def __call__(
+        self,
+        current_working_directory: Path,
+        path: str,
+        *,
+        exclude_type: Literal["file"] | Literal["dir"] | None = None,
+    ) -> tuple[str | None, list[str] | None]:
+        current_working_directory = (
+            current_working_directory.expanduser().resolve().absolute()
+        )
+        directory_path = (current_working_directory / Path(path).expanduser()).resolve()
+
+        node: str = path
+        if not directory_path.is_dir():
+            node = directory_path.name
+            directory_path = directory_path.parent
+
+        if (listing := self.directory_listings.get(directory_path)) is None:
+            read_task = DirectoryReadTask(directory_path)
+            self.read_tasks[directory_path] = read_task
+            read_task.start()
+            listing = await read_task.wait()
+
+        if exclude_type is not None:
+            if exclude_type == "dir":
+                listing = [
+                    listing_path
+                    for listing_path in listing
+                    if not listing_path.is_dir()
+                ]
+            else:
+                listing = [
+                    listing_path for listing_path in listing if listing_path.is_dir()
+                ]
+
+        if not node:
+            return None, [listing_path.name for listing_path in listing]
+
+        matching_nodes = [
+            listing_path
+            for listing_path in listing
+            if listing_path.name.startswith(node)
+        ]
+        if not (matching_nodes):
+            # Nothing matches
+            return None, None
+
+        if not (
+            prefix := longest_common_prefix(
+                [node_path.name for node_path in matching_nodes]
+            )
+        ):
+            return None, None
+
+        picked_path = directory_path / prefix
+        path_size = (
+            len(str(Path(directory_path).expanduser().resolve())) + 1 + len(node)
+        )
+        completed_prefix = str(picked_path)[path_size:]
+        path_options = [
+            str(path)[path_size + len(completed_prefix) :] for path in matching_nodes
+        ]
+        path_options = [name for name in path_options if name]
+
+        if picked_path.is_dir() and not path_options:
+            completed_prefix += os.sep
+
+        return completed_prefix or None, path_options
+
+
+if __name__ == "__main__":
+
+    async def run():
+        path_complete = PathComplete()
+        cwd = Path("~/sandbox")
+
+        print(await path_complete(cwd, "~/p"))
+
+    asyncio.run(run())

toad/path_filter.py

@@ -0,0 +1,124 @@
+from itertools import chain
+from typing import Iterable, Sequence
+from pathlib import Path
+import pathspec
+import pathspec.patterns
+from pathspec import GitIgnoreSpec
+
+import rich.repr
+
+
+def load_path_spec(git_ignore_path: Path) -> GitIgnoreSpec | None:
+    """Get a path spec instance if there is a .gitignore file present.
+
+    Args:
+        git_ignore_path): Path to .gitignore.
+
+    Returns:
+        A `PathSpec` instance.
+    """
+    try:
+        if git_ignore_path.is_file():
+            try:
+                spec_text = git_ignore_path.read_text(encoding="utf-8")
+            except Exception:
+                # Permissions, encoding issue?
+                return None
+            try:
+                spec = GitIgnoreSpec.from_lines(
+                    pathspec.patterns.GitWildMatchPattern, spec_text.splitlines()
+                )
+            except Exception:
+                return None
+            return spec
+    except OSError:
+        return None
+    return None
+
+
+@rich.repr.auto
+class PathFilter:
+    """Filter paths according to .gitignore files."""
+
+    def __init__(
+        self, root: Path, path_specs: Iterable[GitIgnoreSpec] | None = None
+    ) -> None:
+        self._root = root
+        self._default_specs = [] if path_specs is None else list(path_specs)
+        self._path_specs: dict[Path, Sequence[GitIgnoreSpec]] = {}
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        yield (str(self._root),)
+
+    @classmethod
+    def from_git_root(cls, path: Path) -> PathFilter:
+        """Load all path specs from parent directories up to the most recent directory with .git
+
+        Args:
+            path: A directory path.
+
+        Returns:
+            PathFilter instance.
+        """
+        filter_root = path
+        path_specs: list[GitIgnoreSpec] = []
+        try:
+            while (parent := path.parent) != parent:
+                if (path_spec := load_path_spec(path / ".gitignore")) is not None:
+                    path_specs.append(path_spec)
+                if (path / ".git").is_dir():
+                    break
+                path = parent
+            else:
+                del path_specs[:]
+        except OSError:
+            pass
+        return PathFilter(filter_root, reversed(path_specs))
+
+    def get_path_specs(self, path: Path) -> Sequence[GitIgnoreSpec]:
+        """Get a sequence of path specs applicable to the give path.
+
+        This will inherit path specs up to the root path of the filtr.
+
+        Args:
+            path: A directory path
+
+        Returns:
+            A sequence of path specs.
+        """
+        if (cached_path_specs := self._path_specs.get(path)) is not None:
+            return cached_path_specs
+        path_spec = load_path_spec(path / ".gitignore")
+        if path == self._root:
+            path_specs = [path_spec] if path_spec is not None else []
+        else:
+            parent_path_specs = self.get_path_specs(path.parent)
+            path_specs = (
+                parent_path_specs
+                if path_spec is None
+                else [*parent_path_specs, path_spec]
+            )
+        self._path_specs[path] = path_specs
+        return path_specs
+
+    def match(self, path: Path) -> bool:
+        """Match a path againt the path filter.
+
+        Returns:
+            `True` if the path should be removed, `False` if it should be included.
+        """
+        if path.name == ".git":
+            return True
+        path_specs = self.get_path_specs(path.parent)
+        for path_spec in chain(self._default_specs, path_specs):
+            if path_spec.match_file(path):
+                return True
+        return False
+
+
+if __name__ == "__main__":
+    path_filter = PathFilter.from_git_root(Path("."))
+
+    for path in Path(".").iterdir():
+        print(path_filter.match(path), path)
+    print(path_filter)

toad/paths.py

@@ -0,0 +1,71 @@
+from contextlib import suppress
+from pathlib import Path
+from typing import Final
+
+from xdg_base_dirs import xdg_config_home, xdg_data_home, xdg_state_home
+
+
+APP_NAME: Final[str] = "toad"
+
+
+def path_to_name(path: Path) -> str:
+    """Converts a path to a name (suitable as a path component).
+
+    Args:
+        path: A path.
+
+    Returns:
+        A stringified version of the path.
+    """
+    name = str(path.resolve()).lstrip("/").replace("/", "-")
+    return name
+
+
+def get_data() -> Path:
+    """Return (possibly creating) the application data directory."""
+    path = xdg_data_home() / APP_NAME
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path
+
+
+def get_config() -> Path:
+    """Return (possibly creating) the application config directory."""
+    path = xdg_config_home() / APP_NAME
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path
+
+
+def get_state() -> Path:
+    """Return (possibly creating) the application state directory."""
+    path = xdg_state_home() / APP_NAME
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path
+
+
+def get_project_data(project_path: Path) -> Path:
+    """Get a directory for per-project data.
+
+    Args:
+        project_path: Path of project.
+
+    """
+    project_data_path = get_data() / path_to_name(project_path)
+    with suppress(OSError):
+        project_data_path.mkdir(0o700, exist_ok=True, parents=True)
+    return project_data_path
+
+
+def get_log() -> Path:
+    """Get a directory for logs.
+
+    Returns:
+        Path to log directory.
+
+    """
+    path = get_state() / "logs"
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path

toad/pill.py

@@ -0,0 +1,23 @@
+from textual.content import Content
+
+
+def pill(text: Content | str, background: str, foreground: str) -> Content:
+    """Format text as a pill (half block ends).
+
+    Args:
+        text: Pill contents as Content object or text.
+        background: Background color.
+        foreground: Foreground color.
+
+    Returns:
+        Pill content.
+    """
+    content = Content(text) if isinstance(text, str) else text
+    main_style = f"{foreground} on {background}"
+    end_style = f"{background} on transparent r"
+    pill_content = Content.assemble(
+        ("▌", end_style),
+        content.stylize(main_style),
+        ("▐", end_style),
+    )
+    return pill_content

toad/prompt/extract.py

@@ -0,0 +1,19 @@
+import re2 as re
+from typing import Iterable
+
+
+RE_MATCH_FILE_PROMPT = re.compile(r"@(\S+)|@\"(.*)\"")
+
+
+def extract_paths_from_prompt(prompt: str) -> Iterable[tuple[str, int, int]]:
+    """Find file syntax in prompts.
+
+    Args:
+        prompt: A line of prompt.
+
+    Yields:
+        A tuple of (PATH, START, END).
+    """
+    for match in RE_MATCH_FILE_PROMPT.finditer(prompt):
+        path, quoted_path = match.groups()
+        yield (path or quoted_path, match.start(0), match.end(0))

toad/prompt/resource.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+import mimetypes
+from pathlib import Path
+
+
+@dataclass
+class Resource:
+    root: Path
+    path: Path
+    mime_type: str
+    text: str | None
+    data: bytes | None
+
+
+class ResourceError(Exception):
+    """An error occurred reading a resource."""
+
+
+class ResourceNotRelative(ResourceError):
+    """Attempted to read a resource, not in the project directory."""
+
+
+class ResourceReadError(ResourceError):
+    """Failed to read the resource."""
+
+
+def load_resource(root: Path, path: Path) -> Resource:
+    """Load a resource from the project directory.
+
+    Args:
+        root: The project root.
+        path: Relative path within project.
+
+    Returns:
+        A resource.
+    """
+    resource_path = root / path
+
+    if not resource_path.is_relative_to(root):
+        raise ResourceNotRelative("Resource path is not relative to project root.")
+
+    mime_type, encoding = mimetypes.guess_file_type(resource_path)
+    if mime_type is None:
+        mime_type = "application/octet-stream"
+
+    data: bytes | None
+    text: str | None
+
+    try:
+        if encoding is not None:
+            data = resource_path.read_bytes()
+            text = None
+        else:
+            data = None
+            text = resource_path.read_text(encoding, errors="replace")
+    except FileNotFoundError:
+        raise ResourceReadError(f"File not found {str(path)!r}")
+    except Exception as error:
+        raise ResourceReadError(f"Failed to read {str(path)!r}; {error}")
+
+    resource = Resource(
+        root,
+        resource_path,
+        mime_type=mime_type,
+        text=text,
+        data=data,
+    )
+    return resource

toad/protocol.py

@@ -0,0 +1,28 @@
+from typing import Protocol, runtime_checkable, Iterable
+
+from textual.widget import Widget
+
+from toad.menus import MenuItem
+
+
+@runtime_checkable
+class BlockProtocol(Protocol):
+    def block_cursor_up(self) -> Widget | None: ...
+    def block_cursor_down(self) -> Widget | None: ...
+    def get_cursor_block(self) -> Widget | None: ...
+    def block_cursor_clear(self) -> None: ...
+    def block_select(self, widget: Widget) -> None: ...
+
+
+@runtime_checkable
+class MenuProtocol(Protocol):
+    def get_block_menu(self) -> Iterable[MenuItem]: ...
+    def get_block_content(self, destination: str) -> str | None: ...
+
+
+@runtime_checkable
+class ExpandProtocol(Protocol):
+    def can_expand(self) -> bool: ...
+    def expand_block(self) -> None: ...
+    def collapse_block(self) -> None: ...
+    def is_block_expanded(self) -> bool: ...

toad/screens/action_modal.py

@@ -0,0 +1,94 @@
+import shutil
+
+from textual.app import ComposeResult
+from textual import on, work
+from textual import containers
+from textual import getters
+from textual.screen import ModalScreen
+from textual import widgets
+from textual.widget import Widget
+
+from toad.app import ToadApp
+from toad.widgets.command_pane import CommandPane
+
+
+UV_INSTALL = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+
+
+class ActionModal(ModalScreen):
+    """Executes an action command."""
+
+    command_pane = getters.query_one(CommandPane)
+    ok_button = getters.query_one("#ok", widgets.Button)
+
+    app = getters.app(ToadApp)
+
+    BINDINGS = [("escape", "dismiss_modal", "Dismiss")]
+
+    def __init__(
+        self,
+        action: str,
+        agent: str,
+        title: str,
+        command: str,
+        *,
+        bootstrap_uv: bool = False,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        self._action = action
+        self._agent = agent
+        self._title = title
+        self._command = command
+        self._bootstrap_uv = bootstrap_uv
+        super().__init__(name=name, id=id, classes=classes)
+
+    def get_loading_widget(self) -> Widget:
+        return widgets.LoadingIndicator()
+
+    def compose(self) -> ComposeResult:
+        with containers.VerticalGroup(id="container"):
+            yield CommandPane()
+            yield widgets.Button("OK", id="ok", disabled=True)
+
+    def enable_button(self) -> None:
+        self.ok_button.loading = False
+        self.ok_button.disabled = False
+        self.ok_button.focus()
+
+    @on(CommandPane.CommandComplete)
+    def on_command_complete(self, event: CommandPane.CommandComplete) -> None:
+        self.enable_button()
+
+    def on_mount(self) -> None:
+        self.ok_button.loading = True
+        self.command_pane.border_title = self._title
+
+        self.run_command()
+
+    @work()
+    async def run_command(self) -> None:
+        """Write and execute the command."""
+        self.command_pane.anchor()
+        if self._bootstrap_uv and shutil.which("uv") is None:
+            # Bootstrap UV if required
+            await self.command_pane.write(f"$ {UV_INSTALL}\n")
+            await self.command_pane.execute(UV_INSTALL, final=False)
+
+        await self.command_pane.write(f"$ {self._command}\n")
+        action_task = self.command_pane.execute(self._command)
+        await action_task
+        self.app.capture_event(
+            "agent-action",
+            action=self._action,
+            agent=self._agent,
+            fail=self.command_pane.return_code != 0,
+        )
+
+    @on(widgets.Button.Pressed)
+    def on_button_pressed(self) -> None:
+        self.action_dismiss_modal()
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(self.command_pane.return_code)