@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/messages.py

@@ -0,0 +1,144 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from textual.content import Content
+from textual.widget import Widget
+from textual.message import Message
+
+from tui.session_tracker import SessionState
+
+
+class WorkStarted(Message):
+    """Work has started."""
+
+
+class WorkFinished(Message):
+    """Work has finished."""
+
+
+@dataclass
+class HistoryMove(Message):
+    """Getting a new item form history."""
+
+    direction: Literal[-1, +1]
+    shell: bool
+    body: str
+
+
+@dataclass
+class UserInputSubmitted(Message):
+    body: str
+    shell: bool = False
+    auto_complete: bool = False
+
+
+@dataclass
+class PromptSuggestion(Message):
+    suggestion: str
+
+
+@dataclass
+class Dismiss(Message):
+    widget: Widget
+
+    @property
+    def control(self) -> Widget:
+        return self.widget
+
+
+@dataclass
+class InsertPath(Message):
+    path: str
+
+
+@dataclass
+class ChangeMode(Message):
+    mode_id: str | None
+
+
+@dataclass
+class Flash(Message):
+    """Request a message flash.
+
+    Args:
+        Message: Content of flash.
+        style: Semantic style.
+        duration: Duration in seconds or `None` for default.
+    """
+
+    content: str | Content
+    style: Literal["default", "warning", "success", "error"]
+    duration: float | None = None
+
+
+@dataclass
+class ProjectDirectoryUpdated(Message):
+    """The project directory may may changed."""
+
+    project_dir: Path | None = None
+
+
+@dataclass
+class SessionNavigate(Message):
+    """Request to switch session."""
+
+    mode_name: str
+    direction: Literal[-1, +1]
+
+
+@dataclass
+class SessionSwitch(Message):
+    """Switch to specified session."""
+
+    mode_name: str
+
+
+@dataclass
+class SessionNew(Message):
+    """Open a new session."""
+
+    path: str
+    """project directory path."""
+    agent: str
+    """Agent identity."""
+    prompt: str
+    """Initial prompt or command"""
+
+
+@dataclass
+class SessionUpdate(Message):
+    name: str | None = None
+    """Name of the session, or `None` for no change."""
+    subtitle: str | None = None
+    """Session subtitle (name of agent)."""
+    path: str | None = None
+    """Project directory path."""
+    state: SessionState | None = None
+    """New session state."""
+    session_pk: int | None = None
+    """DB primary key of the session."""
+
+
+@dataclass
+class SessionClose(Message):
+    name: str
+    """Name of the session."""
+
+
+@dataclass
+class SessionLoad(Message):
+    """Load a session by ID."""
+
+    session_pk: int
+    """Primary key of the session to load."""
+
+
+@dataclass
+class LaunchAgent(Message):
+    """Inform app to launch agent."""
+
+    identity: str
+    session_id: str | None = None
+    pk: int | None = None
+    prompt: str | None = None

package/tui/option_content.py

@@ -0,0 +1,51 @@
+from textual.content import Content
+from textual.css.styles import RulesMap
+from textual.style import Style
+from textual.visual import Visual, RenderOptions
+from textual.strip import Strip
+
+from itertools import zip_longest
+
+
+class OptionContent(Visual):
+    def __init__(self, option: str | Content, help: str | Content) -> None:
+        self.option = Content(option) if isinstance(option, str) else option
+        self.help = Content(help) if isinstance(help, str) else help
+        self._label = Content(f"{option} {help}")
+
+    def __str__(self) -> str:
+        return str(self.option)
+
+    def render_strips(
+        self, width: int, height: int | None, style: Style, options: RenderOptions
+    ) -> list[Strip]:
+        option_strips = [
+            Strip(
+                self.option.render_segments(style), cell_length=self.option.cell_length
+            )
+        ]
+
+        option_width = self.option.cell_length
+        remaining_width = width - self.option.cell_length
+
+        help_strips = self.help.render_strips(
+            remaining_width, None, style, options=options
+        )
+        help_width = max(strip.cell_length for strip in help_strips)
+        help_width = [strip.extend_cell_length(help_width) for strip in help_strips]
+
+        strips: list[Strip] = []
+        for option_strip, help_strip in zip_longest(option_strips, help_strips):
+            if option_strip is None:
+                option_strip = Strip.blank(option_width)
+            assert isinstance(help_strip, Strip)
+            strips.append(Strip.join([option_strip, help_strip]))
+        return strips
+
+    def get_optimal_width(self, rules: RulesMap, container_width: int) -> int:
+        return self._label.get_optimal_width(rules, container_width)
+
+    def get_height(self, rules: RulesMap, width: int) -> int:
+        label_width = self.option.cell_length + 1
+        height = self.help.get_height(rules, width - label_width)
+        return height

package/tui/path_complete.py

@@ -0,0 +1,217 @@
+import asyncio
+from itertools import islice
+import os
+from pathlib import Path
+from typing import Iterable, Literal
+
+
+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:
+        """Read the directory contents."""
+        # TODO: Arbitary limit, to avoid stalling on very large directories
+        # Should this be configurable?
+        try:
+            for path in islice(self.path.iterdir(), None, 10_000):
+                self.directory_listing.append(path)
+        except OSError:
+            return
+
+    def start(self) -> None:
+        self._task = asyncio.create_task(
+            self.run(), name=f"DirectoryReadTask({str(self.path)!r})"
+        )
+
+    async def run(self):
+        try:
+            await asyncio.to_thread(self.read)
+        finally:
+            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]] = {}
+
+    @classmethod
+    def decorate_listing(cls, paths: Iterable[Path]) -> list[str]:
+        """Add trailing slash to directories.
+
+        Args:
+            paths: A sequence of paths.
+
+        Returns:
+            A list of directory names.
+        """
+        return [(path.name + "/" if path.is_dir() else path.name) for path in paths]
+
+    @classmethod
+    def decorate_path(cls, path: Path) -> str:
+        """Add trailing slash to a path if it is a directory.
+
+        Args:
+            path: Path.
+
+        Returns:
+            The path name, potentially with a trailing slash.
+        """
+        return path.name + "/" if path.is_dir() else path.name
+
+    async def __call__(
+        self,
+        current_working_directory: Path,
+        path: str,
+        *,
+        exclude_type: Literal["file"] | Literal["dir"] | None = None,
+    ) -> tuple[str | None, list[str] | None]:
+        """Attempt to auto-complete a path.
+
+        Args:
+            current_working_directory: Current working directory (to resolve relative paths).
+            path: String potentially containing path to auto-complete.
+            exclude_type: May be `"file"` to exclude files, `"dir"` to exclude directories, or `None` not to exclude anything.
+
+        Returns:
+            A pair of the recommend auto complete (or `None`), and a list of options (or `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()
+
+        def check_completions(
+            listing: list[Path],
+        ) -> tuple[str | None, list[str] | None]:
+            """Check completions from a listing (run in a thread)
+
+            Args:
+                listing: List of paths.
+
+            Returns:
+                Completions.
+            """
+            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, self.decorate_listing(listing)
+
+            node_name = Path(node).name
+
+            if not node_name or path.endswith("/"):
+                return None, self.decorate_listing(listing)
+            matching_nodes = [
+                listing_path
+                for listing_path in listing
+                if listing_path.name.startswith(node_name)
+            ]
+
+            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
+
+            complete_name = Path(path).name
+            completed_prefix = prefix[len(complete_name) :]
+            path_options = [
+                (
+                    matched_path.name[len(complete_name) :] + "/"
+                    if matched_path.is_dir()
+                    else matched_path.name[len(complete_name) :]
+                )
+                for matched_path in matching_nodes
+                if matched_path.name.startswith(complete_name)
+            ]
+
+            if len(path_options) > 1:
+                return None, path_options
+
+            if picked_path.is_dir() and len(path_options) <= 1:
+                completed_prefix += os.sep
+
+            return completed_prefix or None, path_options
+
+        return await asyncio.to_thread(check_completions, listing)
+
+
+if __name__ == "__main__":
+
+    async def run():
+        path_complete = PathComplete()
+        cwd = Path("~/sandbox")
+
+        print(await path_complete(cwd, "~/p"))
+
+    asyncio.run(run())

package/tui/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)

package/tui/paths.py

@@ -0,0 +1,87 @@
+from contextlib import suppress
+from pathlib import Path
+from typing import Final
+
+from xdg_base_dirs import xdg_config_home, xdg_data_home
+
+
+APP_NAME: Final[str] = "tui"
+
+
+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 = Path.home() / ".cdh" / "state" / 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 = Path.home() / ".cdh" / "logs"
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path
+
+
+def get_sessions() -> Path:
+    """Get the platform-level sessions directory (~/.cdh/sessions/).
+
+    Session JSON files are stored by the cdh platform, not by individual
+    agent engines.  The DB index at ~/.cdh/state/tui/tui.db maps each
+    session to its owning engine (B mapping mode).
+
+    Returns:
+        Path to the sessions directory.
+    """
+    path = Path.home() / ".cdh" / "sessions"
+    with suppress(OSError):
+        path.mkdir(0o700, exist_ok=True, parents=True)
+    return path

package/tui/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

package/tui/platform_commands.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+from tui.slash_command import SlashCommand
+
+if TYPE_CHECKING:
+    from tui.widgets.conversation import Conversation
+
+Handler = Callable[["Conversation", str], Awaitable[None]]
+
+
+class _CommandEntry:
+    def __init__(self, command: str, help: str, handler: Handler, hint: str | None = None):
+        self.slash_command = SlashCommand(f"/{command}", help, hint)
+        self.handler = handler
+
+
+_registry: dict[str, _CommandEntry] = {}
+_registry_prefix: str = ""
+
+
+def set_prefix(prefix: str) -> None:
+    global _registry_prefix
+    _registry_prefix = prefix
+
+
+def register(command: str, help: str, handler: Handler, hint: str | None = None) -> None:
+    prefixed = f"{_registry_prefix}{command}"
+    _registry[prefixed] = _CommandEntry(prefixed, help, handler, hint)
+
+
+def clear() -> None:
+    global _registry_prefix
+    _registry.clear()
+    _registry_prefix = ""
+
+
+def get_commands() -> dict[str, _CommandEntry]:
+    return _registry
+
+
+def get_slash_commands() -> list[SlashCommand]:
+    return [entry.slash_command for entry in _registry.values()]
+
+
+async def dispatch(conversation: Conversation, command: str, parameters: str) -> bool:
+    entry = _registry.get(command)
+    if entry is None:
+        return False
+    await entry.handler(conversation, parameters)
+    return True