riched 0.1.0__tar.gz → 0.2.0__tar.gz

{riched-0.1.0 → riched-0.2.0}/AGENTS.md

@@ -2,13 +2,15 @@
 
 ## Project Structure & Module Organization
 
-This repository is a uv-managed Python project for `riched`, a Textual TUI editor. Application code lives in `src/riched/`: `cli.py` owns argument parsing, `app.py` owns the Textual app and file tree, `editor.py` customizes text editing, `screens.py` contains modal screens, `keybindings.py` loads shipped shortcut config and popup display rows, `bindings.yaml` defines shipped bindings, `settings.py` persists user settings such as theme, and `syntax.py` handles language detection/highlighting. End-to-end tests live in `tests/`. Root-level `foo.*` and `hello.txt` files are test fixtures/sample content. Avoid committing generated files such as `.venv/`, `__pycache__/`, `keys.log`, or build artifacts.
+This repository is a uv-managed Python project for `riched`, a Textual TUI editor. Application code lives in `src/riched/`: `cli.py` owns argument parsing, `app.py` owns the Textual app and file tree, `editor.py` customizes text editing, `screens.py` contains modal screens, `quick_open.py` indexes quick-open candidates, `keybindings.py` loads shipped shortcut config and popup display rows, `bindings.yaml` defines shipped bindings, `settings.py` persists user settings such as theme, and `syntax.py` handles language detection/highlighting. End-to-end tests live in `tests/`. Avoid committing generated files such as `.venv/`, `__pycache__/`, `keys.log`, `dist/`, or build artifacts.
 
 ## Build, Test, and Development Commands
 
 - `uv sync`: install project dependencies from `pyproject.toml` and `uv.lock`.
 - `uv run riched path/to/file.txt`: open or create a file in the editor.
 - `uv run python -m tests.runner`: run the Textual Pilot end-to-end suite.
+- `uv build`: build the source distribution and wheel in `dist/`.
+- `uv publish`: publish built distributions for a release.
 - `uv add <package>`: add runtime dependencies; do not use `pip`.
 
 ## Coding Style & Naming Conventions
@@ -19,7 +21,7 @@ Keep key bindings in `src/riched/bindings.yaml`, not hardcoded in Python. The F1
 
 ## Testing Guidelines
 
-Only add end-to-end tests in `tests/`; do not create unit tests. Tests use Textual's Pilot harness and should be named `test_<behavior>`. Keep each test focused on user-visible behavior such as file open/save, dirty prompts, file tree switching, or syntax highlighting. Use temporary files as existing tests do.
+Only add end-to-end tests in `tests/`; do not create unit tests. Tests use Textual's Pilot harness and should be named `test_<behavior>`. Keep each test focused on user-visible behavior such as file open/save, dirty prompts, file tree switching, quick-open search/indexing, or syntax highlighting. Use temporary files as existing tests do.
 
 ## Commit & Pull Request Guidelines
 

{riched-0.1.0 → riched-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riched
-Version: 0.1.0
+Version: 0.2.0
 Summary: A Textual TUI editor
 Requires-Python: >=3.14
 Requires-Dist: pyyaml>=6.0.3
@@ -10,6 +10,8 @@ Description-Content-Type: text/markdown
 
 # Riched
 
+> TUI editor tailored for VSCode keybindigs in Ghostty terminal
+
 `riched` is a TUI editor powered by the [Rich](https://github.com/Textualize/rich) package and the [Textual](https://github.com/Textualize/textual) framework, the name is a nod to Rich.
 
 > [!NOTE]
@@ -19,54 +21,73 @@ Description-Content-Type: text/markdown
 
 ## Key Features
 
+- VS Code-style text editing key bindings
 - Syntax highlighting
 - Resizable project file tree
-- VS Code-style text editing key bindings
+- Quick open with git-aware indexing, bounded large-folder scanning
+- fuzzy matching, symlink traversal
 
 ## Usage
 
+```sh
+uv tool install riched
+riched .
+```
+
+## Dev
+
 ```sh
 uv sync
-uv run riched . 
+uv run riched .
 uv run python -m tests.runner
+uv build
+uv publish
 ```
 
 ## Key Bindings
 
 Key bindings are generated from the YAML in `src/riched/bindings.yaml`.
+Symbols: `⌘` = Command, `⌃` = Control, `⌥` = Option, `⇧` = Shift.
 
 App shortcuts:
 
 | Shortcut | Action |
 | --- | --- |
-| `Ctrl+S` | Save |
-| `Ctrl+Q` | Quit |
-| `Ctrl+W` | Close buffer |
+| `⌃S` | Save |
+| `⌃Q` | Quit |
+| `⌃W` | Close buffer |
 | `F1` | Key bindings |
-| `Cmd+B` / `Super+B` | Toggle file tree |
-| `Cmd+P` / `Super+P` | Quick open |
+| `⌘B` | Toggle file tree |
+| `⌘P` | Quick open |
 
 Editor shortcuts:
 
 | Shortcut | Action |
 | --- | --- |
-| `Alt+Up` | Move line up |
-| `Alt+Down` | Move line down |
-| `Alt+Shift+Up` / `Shift+Alt+Up` | Copy line up |
-| `Alt+Shift+Down` / `Shift+Alt+Down` | Copy line down |
-| `Alt+Backspace` | Delete word left |
-| `Alt+Shift+Left` / `Shift+Alt+Left` | Select word left |
-| `Alt+Shift+Right` / `Shift+Alt+Right` | Select word right |
-| `Super+L` / `Cmd+L` | Select line |
-| `Shift+Super+Left` / `Super+Shift+Left` / `Shift+Cmd+Left` / `Cmd+Shift+Left` | Select to line start |
-| `Shift+Super+Right` / `Super+Shift+Right` / `Shift+Cmd+Right` / `Cmd+Shift+Right` | Select to line end |
+| `⌥↑` | Move line up |
+| `⌥↓` | Move line down |
+| `⌥⇧↑` | Copy line up |
+| `⌥⇧↓` | Copy line down |
+| `⌥⌫` | Delete word left |
+| `⌥⇧←` | Select word left |
+| `⌥⇧→` | Select word right |
+| `⌘L` | Select line |
+| `⌘⇧←` | Select to line start |
+| `⌘⇧→` | Select to line end |
 
 ## Settings
 
 `riched` persists the selected Textual theme in `settings.yaml` under the user
 config directory: `~/Library/Application Support/riched/settings.yaml`
 
+## Release Notes
+
+### 0.2.0
+
+- Quick open now opens immediately while indexing in the background.
+- File search prefers git-indexed files when available, follows symlinked files and directories, skips cache/build dependency folders, and caps indexing at 10,000 files.
+- Fuzzy ranking now prioritizes exact path and filename matches such as `.zshrc`.
+
 ## Won't Implemented
 
 `riched` will not implement key bindings that require users to modify the Ghostty terminal configuration, since terminal-specific configuration makes shortcuts harder to document, test, and support consistently across environments.
-

{riched-0.1.0 → riched-0.2.0}/README.md

@@ -1,5 +1,7 @@
 # Riched
 
+> TUI editor tailored for VSCode keybindigs in Ghostty terminal
+
 `riched` is a TUI editor powered by the [Rich](https://github.com/Textualize/rich) package and the [Textual](https://github.com/Textualize/textual) framework, the name is a nod to Rich.
 
 > [!NOTE]
@@ -9,54 +11,73 @@
 
 ## Key Features
 
+- VS Code-style text editing key bindings
 - Syntax highlighting
 - Resizable project file tree
-- VS Code-style text editing key bindings
+- Quick open with git-aware indexing, bounded large-folder scanning
+- fuzzy matching, symlink traversal
 
 ## Usage
 
+```sh
+uv tool install riched
+riched .
+```
+
+## Dev
+
 ```sh
 uv sync
-uv run riched . 
+uv run riched .
 uv run python -m tests.runner
+uv build
+uv publish
 ```
 
 ## Key Bindings
 
 Key bindings are generated from the YAML in `src/riched/bindings.yaml`.
+Symbols: `⌘` = Command, `⌃` = Control, `⌥` = Option, `⇧` = Shift.
 
 App shortcuts:
 
 | Shortcut | Action |
 | --- | --- |
-| `Ctrl+S` | Save |
-| `Ctrl+Q` | Quit |
-| `Ctrl+W` | Close buffer |
+| `⌃S` | Save |
+| `⌃Q` | Quit |
+| `⌃W` | Close buffer |
 | `F1` | Key bindings |
-| `Cmd+B` / `Super+B` | Toggle file tree |
-| `Cmd+P` / `Super+P` | Quick open |
+| `⌘B` | Toggle file tree |
+| `⌘P` | Quick open |
 
 Editor shortcuts:
 
 | Shortcut | Action |
 | --- | --- |
-| `Alt+Up` | Move line up |
-| `Alt+Down` | Move line down |
-| `Alt+Shift+Up` / `Shift+Alt+Up` | Copy line up |
-| `Alt+Shift+Down` / `Shift+Alt+Down` | Copy line down |
-| `Alt+Backspace` | Delete word left |
-| `Alt+Shift+Left` / `Shift+Alt+Left` | Select word left |
-| `Alt+Shift+Right` / `Shift+Alt+Right` | Select word right |
-| `Super+L` / `Cmd+L` | Select line |
-| `Shift+Super+Left` / `Super+Shift+Left` / `Shift+Cmd+Left` / `Cmd+Shift+Left` | Select to line start |
-| `Shift+Super+Right` / `Super+Shift+Right` / `Shift+Cmd+Right` / `Cmd+Shift+Right` | Select to line end |
+| `⌥↑` | Move line up |
+| `⌥↓` | Move line down |
+| `⌥⇧↑` | Copy line up |
+| `⌥⇧↓` | Copy line down |
+| `⌥⌫` | Delete word left |
+| `⌥⇧←` | Select word left |
+| `⌥⇧→` | Select word right |
+| `⌘L` | Select line |
+| `⌘⇧←` | Select to line start |
+| `⌘⇧→` | Select to line end |
 
 ## Settings
 
 `riched` persists the selected Textual theme in `settings.yaml` under the user
 config directory: `~/Library/Application Support/riched/settings.yaml`
 
+## Release Notes
+
+### 0.2.0
+
+- Quick open now opens immediately while indexing in the background.
+- File search prefers git-indexed files when available, follows symlinked files and directories, skips cache/build dependency folders, and caps indexing at 10,000 files.
+- Fuzzy ranking now prioritizes exact path and filename matches such as `.zshrc`.
+
 ## Won't Implemented
 
 `riched` will not implement key bindings that require users to modify the Ghostty terminal configuration, since terminal-specific configuration makes shortcuts harder to document, test, and support consistently across environments.
-

{riched-0.1.0 → riched-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "riched"
-version = "0.1.0"
+version = "0.2.0"
 description = "A Textual TUI editor"
 readme = "README.md"
 requires-python = ">=3.14"

{riched-0.1.0 → riched-0.2.0}/src/riched/app.py

@@ -4,17 +4,25 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import Any
 
-from textual import events
+from textual import events, work
 from textual.app import App, ComposeResult, SystemCommand
 from textual.binding import Binding
 from textual.command import CommandPalette
 from textual.containers import Container, Horizontal
 from textual.keys import format_key
 from textual.screen import Screen
+from textual.worker import get_current_worker
 from textual.widgets import DirectoryTree, Footer, Header, Static, TextArea
 
 from .editor import RichedTextArea
 from .keybindings import display_key
+from .quick_open import (
+    MAX_QUICK_OPEN_INDEX_FILES,
+    QUICK_OPEN_BATCH_SIZE,
+    QuickOpenEntry,
+    git_quick_open_entries,
+    scan_quick_open_entries,
+)
 from .screens import KeysHelpScreen, QuickOpenScreen, UnsavedChangesScreen
 from .settings import load_theme, save_theme
 from .syntax import apply_language
@@ -22,14 +30,6 @@ from .syntax import apply_language
 FILE_TREE_DEFAULT_WIDTH = 30
 FILE_TREE_MIN_WIDTH = 18
 FILE_TREE_MAX_WIDTH = 44
-QUICK_OPEN_SKIP_DIRS = {
-    ".git",
-    ".venv",
-    "__pycache__",
-    "build",
-    "dist",
-    "node_modules",
-}
 KEY_MODIFIER_SYMBOLS = {
     "cmd": "⌘",
     "super": "⌘",
@@ -174,6 +174,12 @@ class RichedApp(App):
         self.path: Path | None = self._initial_path
         self.root = root or Path.cwd()
         self._saved_text = ""
+        self._quick_open_entries: list[QuickOpenEntry] = []
+        self._quick_open_complete = False
+        self._quick_open_indexing = False
+        self._quick_open_limited = False
+        self._quick_open_generation = 0
+        self._quick_open_screen: QuickOpenScreen | None = None
 
     def _save_theme(self, theme: str) -> None:
         try:
@@ -321,36 +327,138 @@ class RichedApp(App):
 
         self.push_screen(UnsavedChangesScreen(), handle)
 
-    def _quick_open_files(self) -> list[Path]:
+    def action_quick_open(self) -> None:
         root = self.root.expanduser()
-        files: list[Path] = []
-        stack = [root]
-        while stack:
-            directory = stack.pop()
-            try:
-                entries = sorted(directory.iterdir(), key=lambda path: path.name.lower())
-            except OSError:
-                continue
-            for entry in entries:
-                try:
-                    if entry.is_dir():
-                        if entry.name not in QUICK_OPEN_SKIP_DIRS and not entry.is_symlink():
-                            stack.append(entry)
-                    elif entry.is_file():
-                        files.append(entry)
-                except OSError:
-                    continue
-        return sorted(files, key=lambda path: path.relative_to(root).as_posix().lower())
+        screen = QuickOpenScreen(
+            root,
+            self._quick_open_entries,
+            indexing=not self._quick_open_complete,
+            limited=self._quick_open_limited,
+        )
+        self._quick_open_screen = screen
 
-    def action_quick_open(self) -> None:
         def handle(selected: Path | None) -> None:
+            if self._quick_open_screen is screen:
+                self._quick_open_screen = None
             if selected is not None:
                 self._switch_path(selected)
 
-        self.push_screen(
-            QuickOpenScreen(self.root.expanduser(), self._quick_open_files()),
-            handle,
-        )
+        self.push_screen(screen, handle)
+        if not self._quick_open_complete and not self._quick_open_indexing:
+            self._start_quick_open_index()
+
+    def _start_quick_open_index(self) -> None:
+        self._quick_open_indexing = True
+        self._build_quick_open_index(self._quick_open_generation)
+
+    @work(thread=True, exclusive=True, group="quick_open_index", exit_on_error=False)
+    def _build_quick_open_index(self, generation: int) -> None:
+        try:
+            root = self.root.expanduser()
+            git_result = git_quick_open_entries(root, MAX_QUICK_OPEN_INDEX_FILES)
+            if git_result is not None:
+                git_entries, limited = git_result
+                self.call_from_thread(
+                    self._replace_quick_open_entries,
+                    generation,
+                    git_entries,
+                    True,
+                    limited,
+                )
+                return
+
+            worker = get_current_worker()
+            batch: list[QuickOpenEntry] = []
+            count = 0
+            limited = False
+            for entry in scan_quick_open_entries(root):
+                if worker.is_cancelled:
+                    return
+                if count >= MAX_QUICK_OPEN_INDEX_FILES:
+                    limited = True
+                    break
+                batch.append(entry)
+                count += 1
+                if len(batch) >= QUICK_OPEN_BATCH_SIZE:
+                    self.call_from_thread(
+                        self._append_quick_open_entries,
+                        generation,
+                        batch,
+                        False,
+                        False,
+                    )
+                    batch = []
+
+            if batch:
+                self.call_from_thread(
+                    self._append_quick_open_entries, generation, batch, False, False
+                )
+            self.call_from_thread(self._finish_quick_open_index, generation, limited)
+        except Exception as exc:
+            self.call_from_thread(
+                self._fail_quick_open_index, generation, str(exc) or type(exc).__name__
+            )
+
+    def _append_quick_open_entries(
+        self,
+        generation: int,
+        entries: list[QuickOpenEntry],
+        complete: bool,
+        limited: bool,
+    ) -> None:
+        if generation != self._quick_open_generation:
+            return
+        self._quick_open_entries.extend(entries)
+        self._quick_open_limited = self._quick_open_limited or limited
+        screen = self._quick_open_screen
+        if screen is not None and screen.is_mounted:
+            screen.append_entries(entries, complete=complete, limited=limited)
+
+    def _replace_quick_open_entries(
+        self,
+        generation: int,
+        entries: list[QuickOpenEntry],
+        complete: bool,
+        limited: bool,
+    ) -> None:
+        if generation != self._quick_open_generation:
+            return
+        self._quick_open_entries = list(entries)
+        self._quick_open_complete = complete
+        self._quick_open_limited = limited
+        self._quick_open_indexing = False
+        screen = self._quick_open_screen
+        if screen is not None and screen.is_mounted:
+            screen.replace_entries(entries, complete=complete, limited=limited)
+
+    def _finish_quick_open_index(self, generation: int, limited: bool) -> None:
+        if generation != self._quick_open_generation:
+            return
+        self._quick_open_complete = True
+        self._quick_open_limited = limited
+        self._quick_open_indexing = False
+        screen = self._quick_open_screen
+        if screen is not None and screen.is_mounted:
+            screen.finish_indexing(limited=limited)
+
+    def _fail_quick_open_index(self, generation: int, message: str) -> None:
+        if generation != self._quick_open_generation:
+            return
+        self._quick_open_complete = True
+        self._quick_open_indexing = False
+        screen = self._quick_open_screen
+        if screen is not None and screen.is_mounted:
+            screen.fail_indexing(message)
+
+    def _invalidate_quick_open_index(self) -> None:
+        self._quick_open_generation += 1
+        self._quick_open_entries = []
+        self._quick_open_complete = False
+        self._quick_open_indexing = False
+        self._quick_open_limited = False
+        screen = self._quick_open_screen
+        if screen is not None and screen.is_mounted:
+            screen.replace_entries([], complete=False, limited=False)
 
     def action_toggle_command_palette(self) -> None:
         if CommandPalette.is_open(self):
@@ -375,6 +483,7 @@ class RichedApp(App):
             self.notify(f"Save failed: {exc}", severity="error")
             return
         self._saved_text = editor.text
+        self._invalidate_quick_open_index()
         self.notify(f"Saved {self.path}")
 
     def action_quit_check(self) -> None:

riched-0.2.0/src/riched/quick_open.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from collections import deque
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+MAX_QUICK_OPEN_INDEX_FILES = 10_000
+QUICK_OPEN_BATCH_SIZE = 512
+QUICK_OPEN_SKIP_DIRS = {
+    ".cache",
+    ".git",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".venv",
+    "__pycache__",
+    "build",
+    "cache",
+    "caches",
+    "dist",
+    "node_modules",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class QuickOpenEntry:
+    """A quick-open candidate with precomputed display text."""
+
+    path: Path
+    relative_path: str
+
+
+def git_quick_open_entries(
+    root: Path, limit: int = MAX_QUICK_OPEN_INDEX_FILES
+) -> tuple[list[QuickOpenEntry], bool] | None:
+    """Return git-aware file candidates, or None when root is not in a repo."""
+
+    process: subprocess.Popen[str] | None = None
+    try:
+        process = subprocess.Popen(
+            [
+                "git",
+                "-C",
+                os.fspath(root),
+                "ls-files",
+                "--cached",
+                "--others",
+                "--exclude-standard",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except OSError:
+        return None
+
+    entries: list[QuickOpenEntry] = []
+    limited = False
+    try:
+        assert process.stdout is not None
+        for line in process.stdout:
+            relative_path = line.strip()
+            if not relative_path or _has_skipped_part(relative_path):
+                continue
+            path = root / relative_path
+            try:
+                if path.is_dir():
+                    if _should_skip_dir(path.name):
+                        continue
+                    for entry in scan_quick_open_entries(path):
+                        if len(entries) >= limit:
+                            limited = True
+                            break
+                        entries.append(
+                            QuickOpenEntry(
+                                entry.path,
+                                _join_relative(relative_path, entry.relative_path),
+                            )
+                        )
+                    if limited:
+                        break
+                elif path.is_file():
+                    if len(entries) >= limit:
+                        limited = True
+                        break
+                    entries.append(QuickOpenEntry(path, relative_path))
+            except OSError:
+                continue
+
+        if limited:
+            process.terminate()
+        return_code = process.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        return None
+    finally:
+        if process.stdout is not None:
+            process.stdout.close()
+
+    if return_code != 0 and not limited:
+        return None
+    return sorted(entries, key=lambda entry: entry.relative_path.lower()), limited
+
+
+def scan_quick_open_entries(root: Path) -> Iterator[QuickOpenEntry]:
+    """Yield fallback candidates breadth-first, following symlinks safely."""
+
+    queue: deque[tuple[str, str]] = deque([(os.fspath(root), "")])
+    visited_directories: set[str] = set()
+    while queue:
+        directory, relative_directory = queue.popleft()
+        try:
+            real_directory = os.path.realpath(directory)
+        except OSError:
+            continue
+        if real_directory in visited_directories:
+            continue
+        visited_directories.add(real_directory)
+
+        try:
+            with os.scandir(directory) as entries:
+                directories: list[tuple[str, str]] = []
+                files: list[QuickOpenEntry] = []
+                for entry in entries:
+                    relative_path = _join_relative(relative_directory, entry.name)
+                    try:
+                        if entry.is_dir(follow_symlinks=True):
+                            if not _should_skip_dir(entry.name):
+                                directories.append((entry.path, relative_path))
+                        elif entry.is_file(follow_symlinks=True):
+                            files.append(
+                                QuickOpenEntry(Path(entry.path), relative_path)
+                            )
+                    except OSError:
+                        continue
+        except OSError:
+            continue
+
+        directories.sort(key=lambda item: item[1].lower())
+        queue.extend(directories)
+        yield from sorted(files, key=lambda entry: entry.relative_path.lower())
+
+
+def _join_relative(directory: str, name: str) -> str:
+    if not directory:
+        return name
+    return f"{directory}/{name}"
+
+
+def _has_skipped_part(relative_path: str) -> bool:
+    return any(_should_skip_dir(part) for part in relative_path.split("/"))
+
+
+def _should_skip_dir(name: str) -> bool:
+    return name in QUICK_OPEN_SKIP_DIRS or name.lower() in QUICK_OPEN_SKIP_DIRS

{riched-0.1.0 → riched-0.2.0}/src/riched/screens.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from heapq import nsmallest
 from pathlib import Path
 
 from textual import events
@@ -10,6 +11,7 @@ from textual.widgets import Button, Input, Label, OptionList, Static
 from textual.widgets.option_list import Option
 
 from .keybindings import binding_help_groups, build_screen_bindings
+from .quick_open import QuickOpenEntry
 
 MAX_QUICK_OPEN_RESULTS = 100
 
@@ -93,18 +95,27 @@ class QuickOpenScreen(ModalScreen[Path | None]):
     }
     """
 
-    def __init__(self, root: Path, files: list[Path]) -> None:
+    def __init__(
+        self,
+        root: Path,
+        entries: list[QuickOpenEntry],
+        *,
+        indexing: bool,
+        limited: bool,
+    ) -> None:
         super().__init__()
         self.root = root
-        self.files = files
-        self._relative_paths = {
-            path: path.relative_to(root).as_posix() for path in files
-        }
+        self.entries = list(entries)
+        self._indexing = indexing
+        self._limited = limited
+        self._error: str | None = None
         self._option_paths: dict[str, Path] = {}
+        self._query = ""
 
     def compose(self) -> ComposeResult:
         with Vertical(id="dialog"):
             yield Input(placeholder="Quick open", id="query")
+            yield Static("", id="status")
             yield OptionList(id="results")
 
     def on_mount(self) -> None:
@@ -144,7 +155,45 @@ class QuickOpenScreen(ModalScreen[Path | None]):
     def action_close(self) -> None:
         self.dismiss(None)
 
+    def append_entries(
+        self,
+        entries: list[QuickOpenEntry],
+        *,
+        complete: bool = False,
+        limited: bool = False,
+    ) -> None:
+        self.entries.extend(entries)
+        if complete:
+            self._indexing = False
+        if limited:
+            self._limited = True
+        self._refresh_results(self._query)
+
+    def replace_entries(
+        self,
+        entries: list[QuickOpenEntry],
+        *,
+        complete: bool,
+        limited: bool,
+    ) -> None:
+        self.entries = list(entries)
+        self._indexing = not complete
+        self._limited = limited
+        self._refresh_results(self._query)
+
+    def finish_indexing(self, *, limited: bool) -> None:
+        self._indexing = False
+        self._limited = limited
+        self._refresh_results(self._query)
+
+    def fail_indexing(self, message: str) -> None:
+        self._indexing = False
+        self._error = message
+        self._refresh_results(self._query)
+
     def _refresh_results(self, query: str) -> None:
+        self._query = query
+        self._refresh_status()
         results = self.query_one("#results", OptionList)
         results.clear_options()
         self._option_paths.clear()
@@ -155,26 +204,42 @@ class QuickOpenScreen(ModalScreen[Path | None]):
             return
 
         options: list[Option] = []
-        for index, path in enumerate(matches[:MAX_QUICK_OPEN_RESULTS]):
+        for index, entry in enumerate(matches[:MAX_QUICK_OPEN_RESULTS]):
             option_id = str(index)
-            self._option_paths[option_id] = path
-            options.append(Option(self._relative_paths[path], id=option_id))
+            self._option_paths[option_id] = entry.path
+            options.append(Option(entry.relative_path, id=option_id))
         results.add_options(options)
         results.highlighted = 0
 
-    def _ranked_matches(self, query: str) -> list[Path]:
+    def _refresh_status(self) -> None:
+        status = self.query_one("#status", Static)
+        if self._error is not None:
+            status.update(f"Indexing failed: {self._error}")
+        elif self._limited:
+            status.update(
+                f"Showing first {len(self.entries)} files; index limit reached."
+            )
+        elif self._indexing:
+            status.update(f"Indexing {len(self.entries)} files...")
+        else:
+            status.update("")
+
+    def _ranked_matches(self, query: str) -> list[QuickOpenEntry]:
         stripped_query = query.strip()
         if not stripped_query:
-            return sorted(self.files, key=lambda path: self._relative_paths[path].lower())
+            return self.entries[:MAX_QUICK_OPEN_RESULTS]
 
-        scored: list[tuple[tuple[int, int, int, int, str], Path]] = []
-        for path in self.files:
-            relative_path = self._relative_paths[path]
-            score = _fuzzy_score(stripped_query, relative_path)
+        scored: list[tuple[tuple[int, int, int, int, str], QuickOpenEntry]] = []
+        for entry in self.entries:
+            score = _fuzzy_score(stripped_query, entry.relative_path)
             if score is not None:
-                scored.append((score, path))
-        scored.sort(key=lambda item: item[0])
-        return [path for _score, path in scored]
+                scored.append((score, entry))
+        return [
+            entry
+            for _score, entry in nsmallest(
+                MAX_QUICK_OPEN_RESULTS, scored, key=lambda item: item[0]
+            )
+        ]
 
     def _open_highlighted(self) -> None:
         results = self.query_one("#results", OptionList)
@@ -264,6 +329,47 @@ class KeysHelpScreen(ModalScreen[None]):
 def _fuzzy_score(query: str, candidate: str) -> tuple[int, int, int, int, str] | None:
     query_lower = query.lower()
     candidate_lower = candidate.lower()
+    basename = Path(candidate_lower).name
+    depth = candidate_lower.count("/")
+
+    if candidate_lower == query_lower:
+        return (0, depth, 0, len(candidate_lower), candidate_lower)
+    if basename == query_lower:
+        return (1, depth, 0, len(candidate_lower), candidate_lower)
+    if basename.startswith(query_lower):
+        return (2, depth, 0, len(candidate_lower), candidate_lower)
+    if candidate_lower.startswith(query_lower):
+        return (3, depth, 0, len(candidate_lower), candidate_lower)
+    if query_lower in basename:
+        return (
+            4,
+            depth,
+            basename.index(query_lower),
+            len(candidate_lower),
+            candidate_lower,
+        )
+    if query_lower in candidate_lower:
+        return (
+            5,
+            depth,
+            candidate_lower.index(query_lower),
+            len(candidate_lower),
+            candidate_lower,
+        )
+
+    basename_score = _fuzzy_positions(query_lower, basename)
+    if basename_score is not None:
+        first, gaps = basename_score
+        return (6, depth, gaps, first, candidate_lower)
+
+    path_score = _fuzzy_positions(query_lower, candidate_lower)
+    if path_score is None:
+        return None
+    first, gaps = path_score
+    return (7, depth, gaps, first, candidate_lower)
+
+
+def _fuzzy_positions(query_lower: str, candidate_lower: str) -> tuple[int, int] | None:
     positions: list[int] = []
     search_from = 0
     for char in query_lower:
@@ -277,8 +383,4 @@ def _fuzzy_score(query: str, candidate: str) -> tuple[int, int, int, int, str] |
     last = positions[-1]
     spread = last - first + 1
     gaps = spread - len(query_lower)
-    basename = Path(candidate_lower).name
-    basename_index = candidate_lower.rfind(basename)
-    basename_bonus = 0 if first >= basename_index else 1
-    contiguous_bonus = 0 if query_lower in candidate_lower else 1
-    return (basename_bonus, contiguous_bonus, gaps, len(candidate_lower), candidate_lower)
+    return first, gaps

{riched-0.1.0 → riched-0.2.0}/tests/runner.py

@@ -47,6 +47,16 @@ from .test_file_tree import (
     test_file_tree_switch_opens_selected_file,
 )
 from .test_footer import test_footer_uses_macos_modifier_symbols
+from .test_quick_open import (
+    test_quick_open_exact_hidden_filename_match_wins,
+    test_quick_open_fallback_follows_symlinks,
+    test_quick_open_fallback_limit_is_visible,
+    test_quick_open_fallback_indexes_by_directory_level,
+    test_quick_open_fallback_skips_heavy_directories,
+    test_quick_open_git_index_limit_is_visible,
+    test_quick_open_git_index_respects_excludes,
+    test_quick_open_screen_opens_before_indexing_completes,
+)
 from .test_syntax import (
     test_python_highlight,
     test_tsx_highlight,
@@ -83,6 +93,32 @@ TESTS: list[tuple[str, Callable[[], Awaitable[None]]]] = [
         "file tree: dirty switch prompts then discard",
         test_file_tree_dirty_switch_prompts_then_discard_opens_file,
     ),
+    (
+        "quick open: screen opens before indexing completes",
+        test_quick_open_screen_opens_before_indexing_completes,
+    ),
+    (
+        "quick open: fallback skips heavy directories",
+        test_quick_open_fallback_skips_heavy_directories,
+    ),
+    (
+        "quick open: fallback indexes by directory level",
+        test_quick_open_fallback_indexes_by_directory_level,
+    ),
+    (
+        "quick open: fallback follows symlinks",
+        test_quick_open_fallback_follows_symlinks,
+    ),
+    (
+        "quick open: git index respects excludes",
+        test_quick_open_git_index_respects_excludes,
+    ),
+    ("quick open: git index limit is visible", test_quick_open_git_index_limit_is_visible),
+    ("quick open: fallback limit is visible", test_quick_open_fallback_limit_is_visible),
+    (
+        "quick open: exact hidden filename match wins",
+        test_quick_open_exact_hidden_filename_match_wins,
+    ),
     ("footer: macOS modifier symbols", test_footer_uses_macos_modifier_symbols),
     ("syntax: python", test_python_highlight),
     ("syntax: typescript", test_typescript_highlight),

{riched-0.1.0 → riched-0.2.0}/tests/test_file_tree.py

@@ -56,4 +56,3 @@ async def test_file_tree_dirty_switch_prompts_then_discard_opens_file() -> None:
         assert editor.text == "second", repr(editor.text)
         assert app.path == second, app.path
     assert first.read_text() == "first"
-

riched-0.2.0/tests/test_quick_open.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import subprocess
+from time import monotonic
+
+from textual.widgets import Static
+
+import riched.app as app_mod
+from riched.screens import QuickOpenScreen
+
+from .helpers import _fresh_env, _make_app
+
+
+async def _wait_for_quick_open_index(app: app_mod.RichedApp, pilot) -> None:
+    deadline = monotonic() + 5
+    while not app._quick_open_complete:
+        assert monotonic() < deadline
+        await pilot.pause()
+
+
+async def test_quick_open_screen_opens_before_indexing_completes() -> None:
+    tmp, _ = _fresh_env()
+    (tmp / "file.txt").write_text("content")
+    app = _make_app(tmp, root=tmp)
+    started = False
+
+    def fake_start() -> None:
+        nonlocal started
+        started = True
+        app._quick_open_indexing = True
+
+    app._start_quick_open_index = fake_start
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await pilot.pause()
+        assert started
+        assert isinstance(app.screen, QuickOpenScreen)
+        status = app.screen.query_one("#status", Static)
+        assert str(status.content) == "Indexing 0 files..."
+
+
+async def test_quick_open_fallback_skips_heavy_directories() -> None:
+    tmp, _ = _fresh_env()
+    (tmp / "keep.py").write_text("keep")
+    for directory in [
+        ".cache",
+        ".venv",
+        "__pycache__",
+        "cache",
+        "caches",
+        "node_modules",
+    ]:
+        skipped = tmp / directory
+        skipped.mkdir()
+        (skipped / "hidden.py").write_text("hidden")
+    case_check = tmp / "case-check"
+    case_check.mkdir()
+    mixed_case_cache = case_check / "Caches"
+    mixed_case_cache.mkdir()
+    (mixed_case_cache / "hidden.py").write_text("hidden")
+
+    app = _make_app(tmp, root=tmp)
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await _wait_for_quick_open_index(app, pilot)
+
+    relative_paths = {entry.relative_path for entry in app._quick_open_entries}
+    assert "keep.py" in relative_paths
+    assert all("hidden.py" not in relative_path for relative_path in relative_paths)
+
+
+async def test_quick_open_fallback_indexes_by_directory_level() -> None:
+    tmp, _ = _fresh_env()
+    (tmp / "root.txt").write_text("root")
+    first = tmp / "first"
+    first.mkdir()
+    (first / "first.txt").write_text("first")
+    second = tmp / "second"
+    second.mkdir()
+    (second / "second.txt").write_text("second")
+    deep = first / "deep"
+    deep.mkdir()
+    (deep / "deep.txt").write_text("deep")
+
+    app = _make_app(tmp, root=tmp)
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await _wait_for_quick_open_index(app, pilot)
+
+    relative_paths = [entry.relative_path for entry in app._quick_open_entries]
+    assert relative_paths.index("root.txt") < relative_paths.index("first/first.txt")
+    assert relative_paths.index("root.txt") < relative_paths.index("second/second.txt")
+    assert relative_paths.index("second/second.txt") < relative_paths.index(
+        "first/deep/deep.txt"
+    )
+
+
+async def test_quick_open_fallback_follows_symlinks() -> None:
+    tmp, _ = _fresh_env()
+    outside = tmp / "outside"
+    outside.mkdir()
+    (outside / "target.txt").write_text("target")
+    (outside / "linked-file.txt").write_text("linked file")
+    (tmp / "linked-dir").symlink_to(outside, target_is_directory=True)
+    (tmp / "file-link.txt").symlink_to(outside / "linked-file.txt")
+    (outside / "loop").symlink_to(tmp, target_is_directory=True)
+
+    app = _make_app(tmp, root=tmp)
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await _wait_for_quick_open_index(app, pilot)
+
+    relative_paths = [entry.relative_path for entry in app._quick_open_entries]
+    assert "file-link.txt" in relative_paths
+    assert "linked-dir/target.txt" in relative_paths
+    assert len(relative_paths) == len(set(relative_paths))
+
+
+async def test_quick_open_git_index_respects_excludes() -> None:
+    tmp, _ = _fresh_env()
+    subprocess.run(["git", "init"], cwd=tmp, check=True, capture_output=True)
+    (tmp / ".gitignore").write_text("*.log\n")
+    (tmp / "tracked.py").write_text("tracked")
+    (tmp / "untracked.py").write_text("untracked")
+    (tmp / "ignored.log").write_text("ignored")
+    subprocess.run(
+        ["git", "add", ".gitignore", "tracked.py"],
+        cwd=tmp,
+        check=True,
+        capture_output=True,
+    )
+
+    app = _make_app(tmp, root=tmp)
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await _wait_for_quick_open_index(app, pilot)
+
+    relative_paths = {entry.relative_path for entry in app._quick_open_entries}
+    assert "tracked.py" in relative_paths
+    assert "untracked.py" in relative_paths
+    assert "ignored.log" not in relative_paths
+
+
+async def test_quick_open_git_index_limit_is_visible() -> None:
+    tmp, _ = _fresh_env()
+    subprocess.run(["git", "init"], cwd=tmp, check=True, capture_output=True)
+    for index in range(5):
+        (tmp / f"file-{index}.txt").write_text(str(index))
+
+    old_limit = app_mod.MAX_QUICK_OPEN_INDEX_FILES
+    app_mod.MAX_QUICK_OPEN_INDEX_FILES = 3
+    try:
+        app = _make_app(tmp, root=tmp)
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app.action_quick_open()
+            await _wait_for_quick_open_index(app, pilot)
+            assert isinstance(app.screen, QuickOpenScreen)
+            status = app.screen.query_one("#status", Static)
+            assert len(app._quick_open_entries) == 3
+            assert str(status.content) == "Showing first 3 files; index limit reached."
+    finally:
+        app_mod.MAX_QUICK_OPEN_INDEX_FILES = old_limit
+
+
+async def test_quick_open_fallback_limit_is_visible() -> None:
+    tmp, _ = _fresh_env()
+    for index in range(5):
+        (tmp / f"file-{index}.txt").write_text(str(index))
+
+    old_limit = app_mod.MAX_QUICK_OPEN_INDEX_FILES
+    app_mod.MAX_QUICK_OPEN_INDEX_FILES = 3
+    try:
+        app = _make_app(tmp, root=tmp)
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app.action_quick_open()
+            await _wait_for_quick_open_index(app, pilot)
+            assert isinstance(app.screen, QuickOpenScreen)
+            status = app.screen.query_one("#status", Static)
+            assert str(status.content) == "Showing first 3 files; index limit reached."
+    finally:
+        app_mod.MAX_QUICK_OPEN_INDEX_FILES = old_limit
+
+
+async def test_quick_open_exact_hidden_filename_match_wins() -> None:
+    tmp, _ = _fresh_env()
+    (tmp / ".zshrc").write_text("target")
+    nested = tmp / "nested"
+    nested.mkdir()
+    (nested / ".zshrc").write_text("nested")
+    (tmp / ".zshrc.backup").write_text("backup")
+    (tmp / "notes-zshrc.txt").write_text("notes")
+
+    app = _make_app(tmp, root=tmp)
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.action_quick_open()
+        await _wait_for_quick_open_index(app, pilot)
+        assert isinstance(app.screen, QuickOpenScreen)
+        matches = app.screen._ranked_matches(".zshrc")
+
+    assert matches[0].relative_path == ".zshrc"

{riched-0.1.0 → riched-0.2.0}/uv.lock

@@ -111,7 +111,7 @@ wheels = [
 
 [[package]]
 name = "riched"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },