@scemoon/cdh 1.0.0

package/tui/widgets/modified_files.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from pathlib import Path
+import subprocess
+
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widgets import Static
+from textual import containers
+
+
+class ModifiedFiles(containers.Vertical):
+    DEFAULT_CSS = """
+    ModifiedFiles {
+        height: auto;
+        max-height: 15;
+        overflow-y: auto;
+
+        Static {
+            padding: 0 1;
+        }
+
+        .file-added {
+            color: $text-success;
+        }
+
+        .file-modified {
+            color: $text-warning;
+        }
+
+        .file-deleted {
+            color: $text-error;
+        }
+
+        .file-renamed {
+            color: $text-secondary;
+        }
+
+        .no-changes {
+            color: $text-secondary;
+            text-style: italic;
+        }
+    }
+    """
+
+    path: reactive[Path | None] = reactive(None)
+    files: reactive[list[str]] = reactive([], recompose=True)
+
+    def __init__(
+        self,
+        path: Path | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        # Initial value is set via data_bind in main.py on_mount.
+        # Don't use set_reactive here — let _initialize_reactive trigger
+        # watch_path properly on first reactive access.
+
+    def watch_path(self, path: Path | None) -> None:
+        """Run git status when path changes."""
+        if path is None:
+            self.files = []
+            return
+        try:
+            result = subprocess.run(
+                ["git", "-C", str(path), "status", "--porcelain"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                self.files = [l for l in result.stdout.strip().split("\n") if l.strip()]
+            else:
+                self.files = []
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            self.files = []
+
+    def refresh_files(self) -> None:
+        """Re-run git status manually (e.g. after file system changes)."""
+        self.watch_path(self.path)
+
+    def compose(self) -> ComposeResult:
+        if not self.files:
+            yield Static("No modified files", classes="no-changes")
+            return
+        for line in self.files:
+            status = line[:2]
+            filepath = line[3:]
+            cls = self._class_for_status(status)
+            yield Static(f" {filepath}", classes=cls)
+
+    @staticmethod
+    def _class_for_status(status: str) -> str:
+        if "?" in status:
+            return "file-added"
+        if "D" in status:
+            return "file-deleted"
+        if "A" in status or "C" in status:
+            return "file-added"
+        if "R" in status:
+            return "file-renamed"
+        if "M" in status:
+            return "file-modified"
+        return "file-modified"

package/tui/widgets/non_selectable_label.py

@@ -0,0 +1,5 @@
+from textual.widgets import Label
+
+
+class NonSelectableLabel(Label):
+    ALLOW_SELECT = False

package/tui/widgets/note.py

@@ -0,0 +1,18 @@
+from typing import Iterable
+from textual.widgets import Static
+
+from tui.menus import MenuItem
+
+
+class Note(Static):
+    DEFAULT_CLASSES = "block"
+
+    def get_block_menu(self) -> Iterable[MenuItem]:
+        return
+        yield
+
+    def get_block_content(self, destination: str) -> str | None:
+        return str(self.render())
+
+    def action_hello(self, message: str) -> None:
+        self.notify(message, severity="warning")

package/tui/widgets/path_search.py

@@ -0,0 +1,492 @@
+from __future__ import annotations
+
+
+import asyncio
+import concurrent.futures
+
+from operator import itemgetter
+import os
+from pathlib import Path
+
+from typing import Sequence
+
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual import work
+from textual import getters
+from textual import containers
+from textual import events
+from textual.actions import SkipAction
+
+from textual.cache import LRUCache
+from textual.reactive import var, Initialize
+from textual.content import Content, Span
+from textual.strip import Strip
+from textual.style import Style
+from textual.widget import Widget
+from textual import widgets
+from textual.visual import RenderOptions
+from textual.widgets import OptionList, Input, DirectoryTree
+from textual.widgets.option_list import Option
+
+from tui import directory
+from tui.fuzzy_index import FuzzyIndex
+from tui.messages import Dismiss, InsertPath, PromptSuggestion
+from tui.path_filter import PathFilter
+from tui.widgets.project_directory_tree import ProjectDirectoryTree
+from tui._path_fuzzy_search import PathFuzzySearch
+from tui._path_match import match_path
+
+
+class PathContent(Content):
+
+    def render_strips(
+        self, width: int, height: int | None, style: Style, options: RenderOptions
+    ) -> list[Strip]:
+        """Render the Visual into an iterable of strips. Part of the Visual protocol.
+
+        Args:
+            width: Width of desired render.
+            height: Height of desired render or `None` for any height.
+            style: The base style to render on top of.
+            options: Additional render options.
+
+        Returns:
+            An list of Strips.
+        """
+        if not width:
+            return []
+
+        line = self
+        if line.cell_length > width:
+            while line.cell_length >= width - 3 and "/" in line.plain:
+                line = line[line.plain.find("/") + 1 :]
+            line = Content.assemble(("⋯ ", "$text-error"), line)
+
+        lines = line._wrap_and_format(
+            width,
+            tab_size=8,
+            overflow="clip",
+            no_wrap=True,
+            selection=options.selection,
+            selection_style=options.selection_style,
+            post_style=options.post_style,
+            get_style=options.get_style,
+        )
+
+        if height is not None:
+            lines = lines[:height]
+
+        strip_lines = [Strip(*line.to_strip(style)) for line in lines]
+        return strip_lines
+
+
+class FuzzyPathOptionList(OptionList):
+    """Option list with loading indicator override."""
+
+    def get_loading_widget(self) -> Widget:
+        from textual.widgets import LoadingIndicator
+
+        return LoadingIndicator()
+
+
+class FuzzyInput(Input):
+    """Adds a Content placeholder to fuzzy input.
+
+    TODO: Add this ability to Textual.
+    """
+
+    HELP = """\
+## Fuzzy search
+
+Type a few characters from the file you are searching for.
+
+The search is *fuzzy*, and will match characters that aren't neccesarily next to each other—only the order matters.
+"""
+
+    def render_line(self, y: int) -> Strip:
+        if y == 0 and not self.value:
+            placeholder = Content.from_markup(self.placeholder).expand_tabs()
+            placeholder = placeholder.stylize(self.visual_style)
+            placeholder = placeholder.stylize(
+                self.get_visual_style("input--placeholder")
+            )
+            if self.has_focus:
+                cursor_style = self.get_visual_style("input--cursor")
+                if self._cursor_visible:
+                    # If the placeholder is empty, there's no characters to stylise
+                    # to make the cursor flash, so use a single space character
+                    if len(placeholder) == 0:
+                        placeholder = Content(" ")
+                    placeholder = placeholder.stylize(cursor_style, 0, 1)
+
+            strip = Strip(placeholder.render_segments())
+            return strip
+
+        return super().render_line(y)
+
+
+class PathSearch(containers.VerticalGroup):
+
+    BINDING_GROUP_TITLE = "Path search"
+
+    CURSOR_BINDING_GROUP = Binding.Group(description="Move selection")
+    BINDINGS = [
+        Binding(
+            "up", "cursor_up", "Cursor up", group=CURSOR_BINDING_GROUP, priority=True
+        ),
+        Binding(
+            "down",
+            "cursor_down",
+            "Cursor down",
+            group=CURSOR_BINDING_GROUP,
+            priority=True,
+        ),
+        Binding("enter", "submit", "Insert path", priority=True, show=False),
+        Binding("escape", "dismiss", "Dismiss", priority=True, show=False),
+        Binding("tab", "switch_picker", "Switch picker", priority=True, show=False),
+    ]
+
+    def get_fuzzy_search(self) -> PathFuzzySearch:
+        return PathFuzzySearch(case_sensitive=False)
+
+    root: var[Path] = var(Path("./"))
+    paths: var[list[Path]] = var(list)
+    display_paths: var[list[str]] = var(list)
+    filtered_path_indices: var[list[int]] = var(list)
+    loaded = var(False)
+    filter = var("")
+    fuzzy_search: var[PathFuzzySearch] = var(Initialize(get_fuzzy_search))
+    show_tree_picker: var[bool] = var(False)
+
+    option_list = getters.query_one(FuzzyPathOptionList)
+    tree_view = getters.query_one(ProjectDirectoryTree)
+    input = getters.query_one(Input)
+
+    def __init__(self, root: Path) -> None:
+        super().__init__()
+        self.set_reactive(PathSearch.root, root)
+        self.root = root
+        self.fuzzy_index = FuzzyIndex()
+        self.pool = concurrent.futures.InterpreterPoolExecutor(
+            thread_name_prefix=f"fuzzy-path-search-{root}"
+        )
+        self.search_cache: LRUCache[str, list[tuple[float, Sequence[int], str]]] = (
+            LRUCache(1024)
+        )
+
+    def compose(self) -> ComposeResult:
+        with widgets.ContentSwitcher(initial="path-search-fuzzy"):
+            with containers.VerticalGroup(id="path-search-fuzzy"):
+                yield FuzzyInput(
+                    compact=True, placeholder="fuzzy search \t[r]▌tab▐[/r] tree view"
+                )
+                yield FuzzyPathOptionList()
+            with containers.VerticalGroup(id="path-search-tree"):
+                yield widgets.Static(
+                    Content.from_markup(
+                        "tree view \t[r]▌tab▐[/] fuzzy search"
+                    ).expand_tabs(),
+                    classes="message",
+                )
+                yield ProjectDirectoryTree(self.root).data_bind(path=PathSearch.root)
+
+    def on_mount(self) -> None:
+        tree = self.tree_view
+        tree.guide_depth = 2
+        tree.center_scroll = True
+
+    def watch_show_tree_picker(self, show_tree_picker: bool) -> None:
+        content_switcher = self.query_one(widgets.ContentSwitcher)
+        content_switcher.current = (
+            "path-search-tree" if show_tree_picker else "path-search-fuzzy"
+        )
+        if show_tree_picker:
+            self.tree_view.focus()
+
+        else:
+            self.input.focus()
+
+    def action_switch_picker(self) -> None:
+        self.show_tree_picker = not self.show_tree_picker
+
+    def fuzzy_match_paths(
+        self, search: str, paths: list[str]
+    ) -> list[tuple[float, Sequence[int], str]]:
+
+        scores = list(
+            self.pool.map(
+                match_path,
+                [(search, path) for path in paths],
+                chunksize=10,
+            )
+        )
+        return scores
+
+    async def search(self, search: str) -> None:
+        if not search:
+            self.option_list.set_options(
+                [
+                    Option(self.highlight_path(path), path)
+                    for path in self.display_paths[:100]
+                ],
+            )
+            return
+
+        display_paths = await self.fuzzy_index.search(search)
+
+        if len(display_paths) > 20:
+            if (scored_paths := self.search_cache.get(search)) is None:
+                scored_paths = await asyncio.to_thread(
+                    self.fuzzy_match_paths, search, display_paths
+                )
+                self.search_cache[search] = scored_paths
+        else:
+            fuzzy_search = self.fuzzy_search
+            scored_paths: list[tuple[float, Sequence[int], str]] = [
+                (
+                    *fuzzy_search.match(search, path),
+                    path,
+                )
+                for path in display_paths
+            ]
+
+        scored_paths = sorted(
+            [score for score in scored_paths if score[0]],
+            key=itemgetter(0),
+            reverse=True,
+        )
+
+        scores = [
+            (score, highlights, self.highlight_path(path))
+            for score, highlights, path in scored_paths[:30]
+        ]
+
+        def highlight_offsets(path: Content, offsets: Sequence[int]) -> Content:
+            highlighted_path = path.add_spans(
+                [Span(offset, offset + 1, "underline") for offset in offsets]
+            )
+            return PathContent(
+                highlighted_path.plain,
+                list(highlighted_path.spans),
+                highlighted_path.cell_length,
+            )
+
+        self.option_list.set_options(
+            [
+                Option(highlight_offsets(path, offsets), id=path.plain)
+                for index, (score, offsets, path) in enumerate(scores)
+            ]
+        )
+        with self.option_list.prevent(OptionList.OptionHighlighted):
+            self.option_list.highlighted = 0
+        self.post_message(PromptSuggestion(""))
+
+    def action_cursor_down(self) -> None:
+        if self.show_tree_picker:
+            self.tree_view.action_cursor_down()
+        else:
+            self.option_list.action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        if self.show_tree_picker:
+            self.tree_view.action_cursor_up()
+        else:
+            self.option_list.action_cursor_up()
+
+    def action_dismiss(self) -> None:
+        self.post_message(Dismiss(self))
+        self.filter = ""
+
+    def on_show(self) -> None:
+        self.focus()
+
+    def focus(self, scroll_visible: bool = False) -> Self:
+        if self.show_tree_picker:
+            return self.tree_view.focus(scroll_visible=scroll_visible)
+        else:
+            return self.input.focus(scroll_visible=scroll_visible)
+
+    def on_descendant_blur(self, event: events.DescendantBlur) -> None:
+        if self.show_tree_picker:
+            if event.widget == self.tree_view:
+                self.post_message(Dismiss(self))
+        else:
+            if event.widget == self.input:
+                self.post_message(Dismiss(self))
+
+    @classmethod
+    def make_relative(cls, path: Path, root: Path) -> Path:
+        """Make a path relative from the root.
+
+        Args:
+            path: Path to consider.
+            root: Root path.
+
+        Returns:
+            A relative path.
+        """
+        return path.resolve().relative_to(root.resolve())
+
+    @on(DirectoryTree.NodeHighlighted)
+    async def on_node_highlighted(self, event: DirectoryTree.NodeHighlighted) -> None:
+        event.stop()
+
+        dir_entry = event.node.data
+        if dir_entry is not None:
+            try:
+                path = await asyncio.to_thread(
+                    self.make_relative, dir_entry.path, self.root
+                )
+            except ValueError:
+                # Being defensive here, shouldn't occur
+                return
+            tree_path = str(path)
+            self.post_message(PromptSuggestion(tree_path))
+
+    @on(DirectoryTree.FileSelected)
+    async def on_file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        event.stop()
+
+        dir_entry = event.node.data
+        if dir_entry is not None:
+            try:
+                path = await asyncio.to_thread(
+                    self.make_relative, dir_entry.path, self.root
+                )
+            except ValueError:
+                return
+            tree_path = str(path)
+            self.post_message(InsertPath(tree_path))
+            self.post_message(Dismiss(self))
+
+    @on(Input.Changed)
+    async def on_input_changed(self, event: Input.Changed):
+        await self.search(event.value)
+
+    @on(OptionList.OptionHighlighted)
+    async def on_option_list_changed(self, event: OptionList.OptionHighlighted):
+        event.stop()
+        if event.option:
+            self.post_message(PromptSuggestion(event.option.id))
+
+    @on(OptionList.OptionSelected)
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        self.action_submit()
+
+    def action_submit(self):
+        if self.show_tree_picker:
+            raise SkipAction()
+
+        elif (highlighted := self.option_list.highlighted) is not None:
+            option = self.option_list.options[highlighted]
+            if option.id:
+                self.post_message(InsertPath(option.id))
+                self.post_message(Dismiss(self))
+
+    def get_path_filter(self, project_path: Path) -> PathFilter:
+        """Get a PathFilter insance for the give project path.
+
+        Args:
+            project_path: Project path.
+
+        Returns:
+            `PathFilter` object.
+        """
+        path_filter = PathFilter.from_git_root(project_path)
+        return path_filter
+
+    def reset(self) -> None:
+        """Reset and focus input."""
+        self.input.clear()
+        self.input.focus()
+
+    @work(exclusive=True)
+    async def refresh_paths(self):
+        self.option_list.set_loading(True)
+        root = self.root
+        try:
+            path_filter = await asyncio.to_thread(self.get_path_filter, root)
+            self.tree_view.path_filter = path_filter
+            self.tree_view.clear()
+            self.tree_view.reload()
+            paths = await directory.scan(
+                root, path_filter=path_filter, add_directories=True
+            )
+
+            def make_absolute(paths: list[Path]) -> list[Path]:
+                """Make all paths absolute.
+
+                Args:
+                    paths: A list of paths.
+
+                Returns:
+                    List of absolute paths,
+
+                """
+                return [path.absolute() for path in paths]
+
+            paths = await asyncio.to_thread(make_absolute, paths)
+            self.root = root
+            self.paths = paths
+        except Exception:
+            self.option_list.set_loading(False)
+            raise
+
+    def highlight_path(self, path: str) -> PathContent:
+        content = Content.styled(path, "$text 50%")
+        if os.path.split(path)[-1].startswith("."):
+            return PathContent(
+                content.plain, list(content.spans), cell_length=content.cell_length
+            )
+        content = content.highlight_regex("[^/]*?$", style="$text-primary")
+        content = content.highlight_regex(r"\.[^/]*$", style="italic")
+        return PathContent(
+            content.plain, list(content.spans), cell_length=content.cell_length
+        )
+
+    @work(description="watch_paths")
+    async def watch_paths(self, paths: list[Path]) -> None:
+
+        def path_display(path: Path) -> str:
+            try:
+                is_directory = path.is_dir()
+            except OSError:
+                is_directory = False
+            if is_directory:
+                return str(path.relative_to(self.root)) + "/"
+            else:
+                return str(path.relative_to(self.root))
+
+        def make_display_paths() -> list[str]:
+            display_paths = sorted(map(path_display, paths), key=str.lower)
+            display_paths.sort(key=lambda path: path.count("/"))
+            return display_paths
+
+        self.display_paths = await asyncio.to_thread(make_display_paths)
+
+        self.option_list.highlighted = None
+        self._update_paths(self.display_paths)
+
+        self.option_list.set_options(
+            [
+                Option(self.highlight_path(path), id=path)
+                for path in self.display_paths[:100]
+            ]
+        )
+        with self.option_list.prevent(OptionList.OptionHighlighted):
+            self.option_list.highlighted = 0
+
+        self.post_message(PromptSuggestion(""))
+
+    @work(description="update_paths")
+    async def _update_paths(self, paths: list[str]) -> None:
+        """Update the paths index.
+
+        Args:
+            paths: A list of paths.
+        """
+        await self.fuzzy_index.update_paths(paths)
+        self.call_after_refresh(self.option_list.set_loading, False)