endpaper 0.0.1__py3-none-any.whl

endpaper/tui/app.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from textual.app import App
+from textual.binding import Binding
+
+from endpaper.core.documents import _read_document, match_document
+from endpaper.core.errors import EndpaperError, UsageError
+from endpaper.core.meetings import create_meeting, scan_meetings
+from endpaper.core.models import DailyNote, Document, ScanWarning, Task, TaskFilter, Workspace
+from endpaper.core.notes import create_note, open_daily_note, scan_notes
+from endpaper.core.tasks import add_task, filter_tasks, load_tasks, match_task, set_task_state
+
+
+class EndpaperApp(App[None]):
+    CSS_PATH = "app.tcss"
+    BINDINGS = [
+        Binding("ctrl+q", "quit", "Quit", show=True, priority=True),
+    ]
+
+    def __init__(self, workspace: Workspace) -> None:
+        super().__init__()
+        self.workspace = workspace
+        self.documents: dict[str, list[Document]] = {"meetings": [], "notes": []}
+        self.warnings: dict[str, list[ScanWarning]] = {"meetings": [], "notes": [], "tasks": []}
+        self.active: str = "meetings"
+        self.visible_documents: list[Document] = []
+        self.last_create_error: str | None = None
+        self._filter_query: str = ""
+        self.tasks: list[Task] = []
+        self.visible_tasks: list[Task] = []
+        self.show_done: bool = False
+        self.last_task_error: str | None = None
+        self._task_filter_query: str = ""
+
+    def on_mount(self) -> None:
+        self.documents["meetings"], self.warnings["meetings"] = scan_meetings(self.workspace)
+        self.documents["notes"], self.warnings["notes"] = scan_notes(self.workspace)
+        self.tasks, self.warnings["tasks"] = load_tasks(self.workspace)
+        self.visible_documents = list(self.documents[self.active])
+        self._refresh_visible_tasks()
+
+        from endpaper.tui.list_screen import ListScreen
+
+        self.push_screen(ListScreen())
+
+    # --- feature 001 compatibility aliases: back when there was only one
+    # collection, these were plain attributes. Kept as properties so the
+    # existing meeting-only tests keep working unedited.
+    @property
+    def meetings(self) -> list[Document]:
+        return self.documents["meetings"]
+
+    @property
+    def visible_meetings(self) -> list[Document]:
+        return self.visible_documents
+
+    def apply_filter(self, query: str) -> None:
+        if self.active == "tasks":
+            self._task_filter_query = query
+            self._refresh_visible_tasks()
+            return
+        self._filter_query = query
+        active_documents = self.documents[self.active]
+        if query:
+            self.visible_documents = [d for d in active_documents if match_document(d, query)]
+        else:
+            self.visible_documents = list(active_documents)
+
+    def refresh_document(self, path: Path) -> None:
+        """Re-parse only the one file that changed, in place, preserving list order.
+        Never rescans the workspace (FR-021, FR-022)."""
+        new_document = _read_document(path)
+        for collection in ("meetings", "notes"):
+            docs = self.documents[collection]
+            index = next((i for i, d in enumerate(docs) if d.path == path), None)
+            if index is None:
+                continue
+            if new_document is not None:
+                docs[index] = new_document
+            else:
+                del docs[index]
+            if collection == self.active:
+                self._sync_visible(path, new_document)
+            return
+
+    def _sync_visible(self, path: Path, new_document: Document | None) -> None:
+        index = next((i for i, d in enumerate(self.visible_documents) if d.path == path), None)
+        if index is None:
+            return
+        still_matches = new_document is not None and (
+            not self._filter_query or match_document(new_document, self._filter_query)
+        )
+        if still_matches:
+            assert new_document is not None
+            self.visible_documents[index] = new_document
+        else:
+            del self.visible_documents[index]
+
+    def switch_collection(self, name: str) -> None:
+        self.active = name
+        if name == "tasks":
+            self._refresh_visible_tasks()
+        else:
+            self.visible_documents = list(self.documents[self.active])
+
+    def _refresh_visible_tasks(self) -> None:
+        task_filter = TaskFilter(include_done=self.show_done)
+        filtered = filter_tasks(self.tasks, task_filter)
+        if self._task_filter_query:
+            filtered = [t for t in filtered if match_task(t, self._task_filter_query)]
+        self.visible_tasks = filtered
+
+    def create_meeting_and_track(self, description: str, type: str) -> Document | None:
+        try:
+            meeting = create_meeting(self.workspace, description, type=type)
+        except UsageError as exc:
+            self.last_create_error = str(exc)
+            return None
+        self.last_create_error = None
+        self.documents["meetings"].insert(0, meeting)
+        # Land back on the collection just created into, so escaping the preview
+        # shows it -- a create is always followed by "let me see that".
+        self.active = "meetings"
+        self.visible_documents = list(self.documents["meetings"])
+        return meeting
+
+    def create_note_and_track(self, description: str, type: str) -> Document | None:
+        try:
+            note = create_note(self.workspace, description, type=type)
+        except UsageError as exc:
+            self.last_create_error = str(exc)
+            return None
+        self.last_create_error = None
+        self.documents["notes"].insert(0, note)
+        self.active = "notes"
+        self.visible_documents = list(self.documents["notes"])
+        return note
+
+    def open_daily_note_and_track(self, *, now: datetime | None = None) -> DailyNote:
+        daily = open_daily_note(self.workspace, now=now)
+        if daily.created and daily.document is not None:
+            self.documents["notes"].insert(0, daily.document)
+        self.active = "notes"
+        self.visible_documents = list(self.documents["notes"])
+        return daily
+
+    def add_task_and_track(self, description: str, type: str) -> Task | None:
+        try:
+            task = add_task(self.workspace, description, type=type)
+        except UsageError as exc:
+            self.last_create_error = str(exc)
+            return None
+        self.last_create_error = None
+        self.tasks.append(task)
+        self.active = "tasks"
+        self._task_filter_query = ""
+        self._refresh_visible_tasks()
+        return task
+
+    def toggle_task_and_track(self, task_id: str) -> None:
+        current = next((t for t in self.tasks if t.id == task_id), None)
+        try:
+            updated = set_task_state(
+                self.workspace, task_id, done=not (current.done if current else False)
+            )
+        except EndpaperError as exc:
+            self.last_task_error = str(exc)
+            return
+        self.last_task_error = None
+        self.tasks = [updated if t.id == task_id else t for t in self.tasks]
+        self._refresh_visible_tasks()
+
+    def toggle_show_done(self) -> None:
+        self.show_done = not self.show_done
+        self._refresh_visible_tasks()

endpaper/tui/app.tcss

@@ -0,0 +1,80 @@
+Screen {
+    layout: vertical;
+}
+
+#body {
+    height: 1fr;
+    layout: horizontal;
+}
+
+#menu-pane {
+    width: 14;
+    border-right: solid $accent;
+}
+
+#list-pane {
+    width: 2fr;
+    border-right: solid $accent;
+}
+
+#preview-pane {
+    width: 3fr;
+    padding: 0 1;
+}
+
+#collection-menu {
+    height: 1fr;
+}
+
+#meeting-list {
+    height: 1fr;
+}
+
+#bottom-bar {
+    dock: bottom;
+    height: auto;
+}
+
+CommandBar {
+    height: 1;
+    display: none;
+}
+
+CommandBar Input {
+    height: 1;
+    border: none;
+    padding: 0;
+}
+
+StatusBar {
+    height: 1;
+    background: $panel;
+}
+
+#editor {
+    height: 1fr;
+    width: 1fr;
+}
+
+#discard-dialog {
+    width: auto;
+    height: auto;
+    padding: 1 2;
+    background: $panel;
+    border: thick $accent;
+    align: center middle;
+}
+
+#discard-buttons {
+    height: auto;
+    align: center middle;
+    padding-top: 1;
+}
+
+#discard-buttons Button {
+    margin: 0 1;
+}
+
+DiscardDialog {
+    align: center middle;
+}

endpaper/tui/command_bar.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import Input, Static
+
+VERBS = {"meeting", "meetings", "note", "notes", "task", "tasks", "init"}
+
+
+def _normalize(text: str) -> str:
+    """Tolerate a literal leading '/' in the typed text.
+
+    The bar is opened by pressing '/', which is not inserted into the input --
+    but users naturally retype it anyway (the footer hint reads "/ filter or
+    command", and it's the universal command-prefix convention), so a leading
+    '/' must not be treated as part of the query/verb.
+    """
+    return text[1:] if text.startswith("/") else text
+
+
+def resolve_mode(text: str) -> tuple[str, str]:
+    """Return (mode, first_token). mode is 'filter' or 'command'.
+
+    A leading space is an escape hatch that forces filter mode (research.md R4).
+    """
+    if text.startswith(" "):
+        return "filter", ""
+    text = _normalize(text)
+    stripped = text.lstrip()
+    if not stripped:
+        return "filter", ""
+    first_token = stripped.split(None, 1)[0]
+    stem = first_token.split(".", 1)[0].lower()
+    if stem in VERBS:
+        return "command", first_token
+    return "filter", ""
+
+
+class CommandBar(Static):
+    BINDINGS = [Binding("escape", "cancel", "Cancel", show=False)]
+
+    class ModeChanged(Message):
+        def __init__(self, mode: str, verb: str) -> None:
+            self.mode = mode
+            self.verb = verb
+            super().__init__()
+
+    class FilterChanged(Message):
+        def __init__(self, query: str) -> None:
+            self.query = query
+            super().__init__()
+
+    class CreateRequested(Message):
+        def __init__(self, kind: str, description: str, type: str) -> None:
+            self.kind = kind  # "meeting" | "note" | "task"
+            self.description = description
+            self.type = type
+            super().__init__()
+
+    class DailyRequested(Message):
+        pass
+
+    class CollectionRequested(Message):
+        def __init__(self, name: str) -> None:
+            self.name = name
+            super().__init__()
+
+    class BarError(Message):
+        def __init__(self, message: str) -> None:
+            self.message = message
+            super().__init__()
+
+    class ClearRequested(Message):
+        pass
+
+    class Closed(Message):
+        pass
+
+    def compose(self) -> ComposeResult:
+        yield Input(placeholder="/ filter or command", id="bar-input")
+
+    def open(self) -> None:
+        self.display = True
+        bar = self.query_one(Input)
+        bar.value = ""
+        bar.focus()
+        self.post_message(self.ModeChanged("filter", ""))
+
+    def close(self) -> None:
+        self.display = False
+        self.post_message(self.Closed())
+
+    def action_cancel(self) -> None:
+        self.query_one(Input).value = ""
+        self.post_message(self.ClearRequested())
+        self.close()
+
+    @on(Input.Changed, "#bar-input")
+    def _on_changed(self, event: Input.Changed) -> None:
+        mode, verb = resolve_mode(event.value)
+        self.post_message(self.ModeChanged(mode, verb))
+        if mode == "filter":
+            # A leading space is the explicit escape hatch for a literal filter
+            # (e.g. the literal word "meetings"); anywhere else, a leading '/' is
+            # the retyped activation key, not part of the query.
+            query = event.value[1:] if event.value.startswith(" ") else _normalize(event.value)
+            self.post_message(self.FilterChanged(query))
+
+    @on(Input.Submitted, "#bar-input")
+    def _on_submitted(self, event: Input.Submitted) -> None:
+        mode, verb_token = resolve_mode(event.value)
+        if mode == "command":
+            self._run_command(event.value, verb_token)
+        self.close()
+
+    def _run_command(self, text: str, verb_token: str) -> None:
+        text = _normalize(text)
+        rest = text[len(verb_token) :].lstrip()
+        stem, _, type_part = verb_token.partition(".")
+        stem = stem.lower()
+        if stem == "meeting":
+            self.post_message(self.CreateRequested("meeting", rest, type_part))
+        elif stem == "meetings":
+            self.post_message(self.CollectionRequested("meetings"))
+        elif stem == "note":
+            if not rest:
+                if type_part:
+                    self.post_message(self.BarError(f"note.{type_part} needs a description"))
+                else:
+                    self.post_message(self.DailyRequested())
+            else:
+                self.post_message(self.CreateRequested("note", rest, type_part))
+        elif stem == "notes":
+            self.post_message(self.CollectionRequested("notes"))
+        elif stem == "task":
+            if not rest:
+                self.post_message(self.BarError("task needs a description"))
+            else:
+                self.post_message(self.CreateRequested("task", rest, type_part))
+        elif stem == "tasks":
+            self.post_message(self.CollectionRequested("tasks"))
+        # "init" is a registered verb for future features; no TUI action this feature.

endpaper/tui/discard_dialog.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label
+
+
+class DiscardDialog(ModalScreen[bool]):
+    def compose(self) -> ComposeResult:
+        with Vertical(id="discard-dialog"):
+            yield Label("Discard unsaved changes?")
+            with Horizontal(id="discard-buttons"):
+                yield Button("Discard", id="discard", variant="error")
+                yield Button("Cancel", id="cancel", variant="primary")
+
+    @on(Button.Pressed, "#discard")
+    def _on_discard(self) -> None:
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#cancel")
+    def _on_cancel(self) -> None:
+        self.dismiss(False)

endpaper/tui/edit_screen.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import TextArea
+
+from endpaper.core.editing import save_buffer
+from endpaper.core.models import EditableFile
+from endpaper.tui.discard_dialog import DiscardDialog
+from endpaper.tui.status_bar import EDIT_HELP, StatusBar
+
+
+class EditScreen(Screen[None]):
+    # TextArea itself binds ctrl+o is unbound but ctrl+s/ctrl+x are (cut); `priority=True`
+    # means these are checked app-down-to-focused-widget, before TextArea's own
+    # bindings, so they aren't shadowed by the focused editor (e.g. TextArea's
+    # built-in ctrl+x -> cut).
+    BINDINGS = [
+        Binding("ctrl+o", "save", "Save", show=True, priority=True),
+        Binding("ctrl+s", "save", "Save", show=False, priority=True),
+        Binding("ctrl+x", "save_and_close", "Save & close", show=True, priority=True),
+        Binding("escape", "close", "Discard", show=True),
+    ]
+
+    def __init__(self, file: EditableFile) -> None:
+        super().__init__()
+        self.file = file
+        self.original_text = file.text
+
+    @property
+    def is_dirty(self) -> bool:
+        return self.query_one("#editor", TextArea).text != self.original_text
+
+    def compose(self) -> ComposeResult:
+        yield TextArea(self.file.text, show_line_numbers=True, id="editor")
+        with Vertical(id="bottom-bar"):
+            yield StatusBar(EDIT_HELP, id="status-bar")
+
+    def on_mount(self) -> None:
+        self.query_one("#editor", TextArea).focus()
+
+    def _render_status(self, note: str | None = None) -> None:
+        status = self.query_one(StatusBar)
+        status.update(f"⚠ {note}   {EDIT_HELP}" if note else EDIT_HELP)
+
+    def _save(self) -> bool:
+        editor = self.query_one("#editor", TextArea)
+        result = save_buffer(self.file.path, editor.text, self.file)
+        if not result.ok:
+            self._render_status(result.message)
+            return False
+
+        if result.saved_text != editor.text:
+            # The stamp changed the `updated:` line -- sync the buffer to match
+            # what actually landed on disk, or the widget would read as dirty
+            # the instant it saved (whenever the new timestamp differs from
+            # what's still displayed). `load_text` resets cursor/selection, so
+            # capture and restore it around the reload (FR-014).
+            cursor = editor.cursor_location
+            editor.text = result.saved_text
+            editor.cursor_location = cursor
+
+        self.original_text = result.saved_text
+        self.file = replace(self.file, text=result.saved_text)
+        self.app.refresh_document(self.file.path)  # type: ignore[attr-defined]
+        if not result.stamped:
+            self._render_status("frontmatter's updated: field could not be found; saved as typed")
+        else:
+            self._render_status(None)
+        return True
+
+    def action_save(self) -> None:
+        self._save()
+
+    def action_save_and_close(self) -> None:
+        if self._save():
+            self.app.pop_screen()
+
+    def action_close(self) -> None:
+        if not self.is_dirty:
+            self.app.pop_screen()
+            return
+
+        def _handle_dismiss(discard: bool | None) -> None:
+            if discard:
+                self.app.pop_screen()
+            else:
+                self.query_one("#editor", TextArea).focus()
+
+        self.app.push_screen(DiscardDialog(), _handle_dismiss)