@scemoon/cdh 1.0.5 → 1.0.7

package/tui/messages.py

@@ -1,144 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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