endpaper 0.0.1__py3-none-any.whl

endpaper/tui/list_screen.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+from typing import cast
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Label, ListItem, ListView, Markdown
+
+from endpaper.core.models import Document, Task
+from endpaper.tui.command_bar import CommandBar
+from endpaper.tui.rendering import render_preview_markdown
+from endpaper.tui.status_bar import LIST_HELP, TASK_LIST_HELP, StatusBar, collection_indicator
+
+EMPTY_STATE_MESSAGE = "No meetings yet. Press / then 'meeting <description>' to create one."
+_NOTES_EMPTY_STATE_MESSAGE = (
+    "No notes yet. Press / then 'note' for today's note, or 'note <description>'."
+)
+_TASKS_EMPTY_STATE_MESSAGE = "No tasks yet. Press / then 'task <description>' to create one."
+
+COLLECTIONS = ("meetings", "notes", "tasks")
+_COLLECTION_LABELS = {"meetings": "Meetings", "notes": "Notes", "tasks": "Tasks"}
+
+
+def _empty_state_message(active: str) -> str:
+    if active == "notes":
+        return _NOTES_EMPTY_STATE_MESSAGE
+    if active == "tasks":
+        return _TASKS_EMPTY_STATE_MESSAGE
+    return EMPTY_STATE_MESSAGE
+
+
+class DocumentRow(ListItem):
+    def __init__(self, document: Document) -> None:
+        super().__init__(Label(self._row_text(document)))
+        self.document = document
+
+    @property
+    def meeting(self) -> Document:
+        """Feature 001 compatibility alias for `document`."""
+        return self.document
+
+    @staticmethod
+    def _row_text(document: Document) -> str:
+        parts = [document.created[:10]]
+        if document.type:
+            parts.append(document.type)
+        parts.append(document.title)
+        if document.tags:
+            parts.append(",".join(document.tags))
+        return "  ".join(parts)
+
+
+MeetingRow = DocumentRow  # alias, feature 001 compatibility
+
+
+class TaskRow(ListItem):
+    def __init__(self, task: Task) -> None:
+        text = self._row_text(task)
+        if task.done:
+            text = f"[strike]{text}[/strike]"
+        super().__init__(Label(text))
+        self.record = task
+
+    @staticmethod
+    def _row_text(task: Task) -> str:
+        parts = ["[x]" if task.done else "[ ]"]
+        if task.created:
+            parts.append(task.created.isoformat())
+        if task.type:
+            parts.append(task.type)
+        parts.append(task.text)
+        if task.tags:
+            parts.append(",".join(task.tags))
+        return "  ".join(parts)
+
+
+class CollectionRow(ListItem):
+    def __init__(self, name: str) -> None:
+        super().__init__(Label(_COLLECTION_LABELS[name]))
+        self.collection_name = name
+
+
+class ListScreen(Screen[None]):
+    BINDINGS = [
+        ("j", "cursor_down", "Down"),
+        ("k", "cursor_up", "Up"),
+        ("h", "focus_menu", "Menu"),
+        ("left", "focus_menu", "Menu"),
+        ("l", "focus_list", "List"),
+        ("right", "focus_list", "List"),
+        ("/", "open_command_bar", "Filter/command"),
+        ("space", "toggle_task", "Toggle"),
+        ("a", "toggle_show_done", "All"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._last_previewed_id: str | None = None
+        self._pending_error: str | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="body"):
+            with Vertical(id="menu-pane"):
+                yield ListView(id="collection-menu")
+            with Vertical(id="list-pane"):
+                yield ListView(id="meeting-list")
+            with Vertical(id="preview-pane"):
+                yield Markdown(id="preview")
+        with Vertical(id="bottom-bar"):
+            yield CommandBar(id="command-bar")
+            yield StatusBar(LIST_HELP, id="status-bar")
+
+    async def on_mount(self) -> None:
+        menu = self.query_one("#collection-menu", ListView)
+        await menu.extend(CollectionRow(name) for name in COLLECTIONS)
+        self.query_one("#meeting-list", ListView).focus()
+        await self.refresh_rows()
+
+    async def on_screen_resume(self) -> None:
+        # Coming back from PreviewScreen: a document may have been created while we
+        # were away (command bar create lands straight in preview, without ever
+        # selecting a row), so the rows built at initial mount are potentially
+        # stale. Rebuild, preferring the document that was actually being previewed
+        # over whatever the list happened to have highlighted before it was opened.
+        await self.refresh_rows(select_id=self._last_previewed_id)
+
+    def _sync_menu_highlight(self) -> None:
+        menu = self.query_one("#collection-menu", ListView)
+        active = self.app.active  # type: ignore[attr-defined]
+        index = COLLECTIONS.index(active)
+        if menu.index != index:
+            menu.index = index
+
+    async def refresh_rows(
+        self, *, select_id: str | None = None, reset_selection: bool = False
+    ) -> None:
+        app = self.app
+        list_view = self.query_one("#meeting-list", ListView)
+        is_tasks = app.active == "tasks"  # type: ignore[attr-defined]
+
+        if select_id is None and not reset_selection:
+            highlighted = list_view.highlighted_child
+            if isinstance(highlighted, DocumentRow):
+                select_id = highlighted.document.id
+            elif isinstance(highlighted, TaskRow):
+                select_id = highlighted.record.id
+
+        # The removal side of clear() is scheduled, not immediate -- awaiting it
+        # (and the mount below) keeps list_view._nodes in sync with what's on
+        # screen before `.index` is set, so the reactive's highlight watcher
+        # marks the row actually being displayed rather than one about to be
+        # removed or not yet mounted.
+        await list_view.clear()
+        items = cast(
+            "list[Document | Task]",
+            app.visible_tasks if is_tasks else app.visible_documents,  # type: ignore[attr-defined]
+        )
+        if not items:
+            await list_view.append(ListItem(Label(_empty_state_message(app.active))))  # type: ignore[attr-defined]
+        else:
+            rows = [TaskRow(item) if is_tasks else DocumentRow(item) for item in items]  # type: ignore[arg-type]
+            await list_view.extend(rows)
+            index = 0
+            if select_id is not None:
+                for i, item in enumerate(items):
+                    if item.id == select_id:
+                        index = i
+                        break
+            list_view.index = index
+        self._sync_menu_highlight()
+        self._update_preview()
+        self._render_status()
+
+    def _update_preview(self) -> None:
+        list_view = self.query_one("#meeting-list", ListView)
+        preview = self.query_one("#preview", Markdown)
+        highlighted = list_view.highlighted_child
+        if isinstance(highlighted, DocumentRow):
+            preview.update(render_preview_markdown(highlighted.document.path, highlighted.document))
+        else:
+            preview.update("")
+
+    def _render_status(
+        self,
+        mode: str | None = None,
+        verb: str = "",
+        bar_open: bool = False,
+        error: str | None = None,
+    ) -> None:
+        status = self.query_one(StatusBar)
+        if error:
+            status.update(f"⚠ {error}")
+            return
+        if bar_open and mode:
+            label = f"[command: {verb}]" if mode == "command" else "[filter]"
+            status.update(f"{label}   enter run   esc cancel")
+            return
+        active = self.app.active  # type: ignore[attr-defined]
+        help_text = TASK_LIST_HELP if active == "tasks" else LIST_HELP
+        text = f"{collection_indicator(active)}   {help_text}"
+        warnings = len(self.app.warnings[active])  # type: ignore[attr-defined]
+        if warnings:
+            text += f"   {warnings} warning{'s' if warnings != 1 else ''}"
+        status.update(text)
+
+    @on(ListView.Highlighted, "#meeting-list")
+    def _on_highlighted(self, event: ListView.Highlighted) -> None:
+        self._update_preview()
+
+    @on(ListView.Selected, "#meeting-list")
+    def _on_selected(self, event: ListView.Selected) -> None:
+        if isinstance(event.item, DocumentRow):
+            from endpaper.tui.preview_screen import PreviewScreen
+
+            document = event.item.document
+            self._last_previewed_id = document.id
+            self.app.push_screen(PreviewScreen(document.path, document))
+
+    @on(ListView.Highlighted, "#collection-menu")
+    async def _on_menu_highlighted(self, event: ListView.Highlighted) -> None:
+        item = event.item
+        if isinstance(item, CollectionRow) and item.collection_name != self.app.active:  # type: ignore[attr-defined]
+            self.app.switch_collection(item.collection_name)  # type: ignore[attr-defined]
+            await self.refresh_rows(reset_selection=True)
+
+    @on(ListView.Selected, "#collection-menu")
+    def _on_menu_selected(self, event: ListView.Selected) -> None:
+        self.query_one("#meeting-list", ListView).focus()
+
+    def _focused_list(self) -> ListView:
+        focused = self.focused
+        if isinstance(focused, ListView) and focused.id == "collection-menu":
+            return focused
+        return self.query_one("#meeting-list", ListView)
+
+    def action_cursor_down(self) -> None:
+        self._focused_list().action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self._focused_list().action_cursor_up()
+
+    def action_focus_menu(self) -> None:
+        self.query_one("#collection-menu", ListView).focus()
+
+    def action_focus_list(self) -> None:
+        self.query_one("#meeting-list", ListView).focus()
+
+    def action_open_command_bar(self) -> None:
+        self.query_one(CommandBar).open()
+
+    async def action_toggle_task(self) -> None:
+        if self.app.active != "tasks":  # type: ignore[attr-defined]
+            return
+        list_view = self.query_one("#meeting-list", ListView)
+        highlighted = list_view.highlighted_child
+        if not isinstance(highlighted, TaskRow) or highlighted.record.id is None:
+            return
+        task_id = highlighted.record.id
+        self.app.toggle_task_and_track(task_id)  # type: ignore[attr-defined]
+        error = self.app.last_task_error  # type: ignore[attr-defined]
+        await self.refresh_rows(select_id=task_id)
+        if error:
+            self._render_status(error=error)
+
+    async def action_toggle_show_done(self) -> None:
+        if self.app.active != "tasks":  # type: ignore[attr-defined]
+            return
+        self.app.toggle_show_done()  # type: ignore[attr-defined]
+        await self.refresh_rows()
+
+    @on(CommandBar.ModeChanged)
+    def _on_mode_changed(self, message: CommandBar.ModeChanged) -> None:
+        self._render_status(mode=message.mode, verb=message.verb, bar_open=True)
+
+    @on(CommandBar.FilterChanged)
+    async def _on_filter_changed(self, message: CommandBar.FilterChanged) -> None:
+        self.app.apply_filter(message.query)  # type: ignore[attr-defined]
+        await self.refresh_rows()
+
+    @on(CommandBar.ClearRequested)
+    async def _on_clear_requested(self, message: CommandBar.ClearRequested) -> None:
+        self.app.apply_filter("")  # type: ignore[attr-defined]
+        await self.refresh_rows()
+
+    @on(CommandBar.CreateRequested)
+    async def _on_create_requested(self, message: CommandBar.CreateRequested) -> None:
+        if message.kind == "task":
+            task = self.app.add_task_and_track(  # type: ignore[attr-defined]
+                message.description, message.type
+            )
+            if task is not None:
+                self._pending_error = None
+                await self.refresh_rows(select_id=task.id)
+            else:
+                self._pending_error = self.app.last_create_error  # type: ignore[attr-defined]
+            return
+        if message.kind == "note":
+            document = self.app.create_note_and_track(  # type: ignore[attr-defined]
+                message.description, message.type
+            )
+        else:
+            document = self.app.create_meeting_and_track(  # type: ignore[attr-defined]
+                message.description, message.type
+            )
+        if document is not None:
+            from endpaper.tui.preview_screen import PreviewScreen
+
+            self._last_previewed_id = document.id
+            self._pending_error = None
+            self.app.push_screen(PreviewScreen(document.path, document))
+        else:
+            self._pending_error = self.app.last_create_error  # type: ignore[attr-defined]
+
+    @on(CommandBar.DailyRequested)
+    def _on_daily_requested(self, message: CommandBar.DailyRequested) -> None:
+        daily = self.app.open_daily_note_and_track()  # type: ignore[attr-defined]
+        from endpaper.tui.preview_screen import PreviewScreen
+
+        if daily.document is not None:
+            self._last_previewed_id = daily.document.id
+            self._pending_error = None
+            self.app.push_screen(PreviewScreen(daily.path, daily.document))
+        else:
+            self._pending_error = None
+            self.app.push_screen(
+                PreviewScreen(daily.path, None, note="frontmatter could not be read")
+            )
+
+    @on(CommandBar.CollectionRequested)
+    async def _on_collection_requested(self, message: CommandBar.CollectionRequested) -> None:
+        self.app.switch_collection(message.name)  # type: ignore[attr-defined]
+        self._pending_error = None
+        await self.refresh_rows(reset_selection=True)
+
+    @on(CommandBar.BarError)
+    def _on_bar_error(self, message: CommandBar.BarError) -> None:
+        self._pending_error = message.message
+
+    @on(CommandBar.Closed)
+    def _on_command_bar_closed(self, message: CommandBar.Closed) -> None:
+        self._render_status(error=self._pending_error)
+        self._pending_error = None
+        self.query_one("#meeting-list", ListView).focus()

endpaper/tui/preview_screen.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Markdown
+
+from endpaper.core.documents import _read_document
+from endpaper.core.editing import load_for_edit
+from endpaper.core.models import Document
+from endpaper.tui.rendering import render_preview_markdown
+from endpaper.tui.status_bar import PREVIEW_HELP, StatusBar
+
+
+class PreviewScreen(Screen[None]):
+    BINDINGS = [
+        Binding("e", "edit", "Edit", show=True),
+        Binding("escape", "close_preview", "Back", show=True),
+    ]
+
+    def __init__(self, path: Path, document: Document | None, *, note: str | None = None) -> None:
+        super().__init__()
+        self.path = path
+        self.document = document
+        self._note = note
+        self._resumed_once = False
+
+    @property
+    def meeting(self) -> Document | None:
+        """Feature 001 compatibility alias for `document`."""
+        return self.document
+
+    def compose(self) -> ComposeResult:
+        yield Markdown(id="full-preview")
+        with Vertical(id="bottom-bar"):
+            yield StatusBar(PREVIEW_HELP, id="status-bar")
+
+    def on_mount(self) -> None:
+        self._update_content()
+        if self._note:
+            self.query_one(StatusBar).update(f"⚠ {self._note}   {PREVIEW_HELP}")
+
+    def on_screen_resume(self) -> None:
+        # `ScreenResume` also fires once at the initial push, coincident with
+        # `on_mount`; only re-render on a genuine return to this screen (e.g.
+        # popping back from EditScreen after a save), FR-007.
+        if not self._resumed_once:
+            self._resumed_once = True
+            return
+        self.document = _read_document(self.path)
+        self._update_content()
+
+    def _update_content(self) -> None:
+        self.query_one("#full-preview", Markdown).update(
+            render_preview_markdown(self.path, self.document)
+        )
+
+    def action_edit(self) -> None:
+        from endpaper.tui.edit_screen import EditScreen
+
+        file = load_for_edit(self.path)
+        self.app.push_screen(EditScreen(file))
+
+    def action_close_preview(self) -> None:
+        self.app.pop_screen()

endpaper/tui/rendering.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from endpaper.core.models import Document
+
+
+def _strip_frontmatter(text: str) -> str:
+    if not text.startswith("---\n"):
+        return text
+    end = text.find("\n---", 3)
+    if end == -1:
+        return text
+    return text[end + 4 :].lstrip("\n")
+
+
+def render_preview_markdown(path: Path, document: Document | None) -> str:
+    """Build the markdown shown in the preview panes: a heading and metadata line,
+    never the raw frontmatter block (which is not valid standalone markdown and
+    collapses into a single paragraph if rendered directly).
+
+    When `document` is None (an existing file whose frontmatter does not parse),
+    falls back to a filename heading with no metadata line -- nothing is invented
+    for fields that could not be read."""
+    text = path.read_text(encoding="utf-8", errors="replace")
+    body = _strip_frontmatter(text)
+
+    if document is None:
+        heading = f"# {path.name}"
+        return f"{heading}\n\n{body}" if body else f"{heading}\n"
+
+    meta_parts = [document.created[:10]]
+    if document.type:
+        meta_parts.append(document.type)
+    if document.tags:
+        meta_parts.append(", ".join(f"#{tag}" for tag in document.tags))
+    meta = " · ".join(meta_parts)
+
+    heading = f"# {document.title}" if document.title else "# (untitled)"
+    if body:
+        return f"{heading}\n\n*{meta}*\n\n{body}"
+    return f"{heading}\n\n*{meta}*\n"

endpaper/tui/status_bar.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from textual.widgets import Static
+
+LIST_HELP = "/ filter or command   ↑↓/jk move   h/l pane   enter open   ctrl+q quit"
+TASK_LIST_HELP = "/ filter or command   ↑↓/jk move   h/l pane   space toggle   a all   ctrl+q quit"
+PREVIEW_HELP = "e edit   esc back   ↑↓/pgup/pgdn scroll   ctrl+q quit"
+EDIT_HELP = "ctrl+o save   ctrl+x save & back   esc discard   ctrl+q quit"
+
+
+def collection_indicator(active: str) -> str:
+    return f"[{active}]"
+
+
+class StatusBar(Static):
+    pass

endpaper-0.0.1.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: endpaper
+Version: 0.0.1
+Summary: A corporate-friendly Markdown notes engine that makes your AI happy.
+License: MIT License
+        
+        Copyright (c) 2026 Ryan Stalets
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: textual>=8.2
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# endpaper
+
+```
+⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣤⣤⣄⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⢀⣠⣶⣾⡿⠿⢛⣛⣛⣛⡛⠻⠿⣿⣷⣦⡀⠀⠀⠀⠀⠀
+⠀⠀⢀⣴⣿⡿⠛⠁⠀⣴⣿⣿⣿⣿⣿⣷⡄⠀⠉⠻⣿⣷⡀⠀⠀⠀
+⠀⢀⣾⡿⠋⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⡧⠀⠀⠀⠈⠻⣿⣦⠀⠀
+⢀⣿⡿⢁⣠⣤⣤⣤⣈⢿⣿⣿⣿⣿⣿⣿⠇⣠⣤⣤⣤⣀⠹⣿⣧⠀
+⣼⣿⢳⣿⣿⣿⣿⣿⣿⣧⠙⢻⣿⣿⠛⢡⣾⣿⣿⣿⣿⣿⣷⣻⣿⡀
+⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢸⣿⣿⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇
+⣿⣿⠘⣿⣿⣿⣿⣿⣿⣿⡀⢸⣿⣿⠀⣸⣿⣿⣿⣿⣿⣿⡿⢹⣿⡇
+⢿⣿⡄⠈⠙⠛⠟⠛⠙⢿⣿⣾⣿⣿⣾⣿⠟⠙⠛⠟⠛⠉⠀⣸⣿⠁
+⠈⣿⣷⡀⠀⠀⠀⠀⠀⠀⠙⢿⣿⣿⡟⠃⠀⠀⠀⠀⠀⠀⣰⣿⡟⠀
+⠀⠘⢿⣷⣄⠀⠀⠀⠀⠀⠀⢸⣿⣿⠀⠀⠀⠀⠀⠀⢀⣴⣿⠟⠀⠀
+⠀⠀⠈⠻⣿⣷⣄⡀⠀⠀⠀⢸⣿⣿⠀⠀⠀⠀⢀⣴⣿⡿⠃⠀⠀⠀
+⠀⠀⠀⠀⠈⠙⠿⣿⣷⣶⣤⣼⣛⣻⣤⣤⣶⣾⡿⠟⠋⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠛⠛⠛⠛⠛⠛⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀
+KEEP YOUR CORPO OVERLORDS HAPPY, FEED YOUR AI
+```
+
+**A corporate-friendly Markdown notes engine that makes your AI happy.**
+
+A local-only, terminal-based tool for capturing and organizing meeting notes, general notes, and tasks as plain markdown files — structured enough for a human to navigate through a TUI, and legible enough that an AI assistant can search and edit the vault through a CLI without any integration work.
+
+## Why
+
+Markdown is the native format of AI assistants — they read it, write it, diff it, and reason over it without an adapter layer. Almost nobody at a large company can actually work that way, because the sanctioned note-taking tools (OneNote, Confluence, SharePoint) lock notes behind proprietary formats and authenticated APIs, and markdown-first apps like Obsidian or Logseq are rarely on the approved-software list.
+
+endpaper installs without admin rights, stores nothing outside a directory you already have, and needs no server or account — just a folder.
+
+The tool disappears into the twenty seconds before a meeting starts. You type `/meeting.standup Q3 planning #platform`, a file exists with correct frontmatter and a date-stamped name, and you're typing notes before anyone has finished joining the call. You never decide where a file goes or what to call it.
+
+## Usage
+
+### Install
+
+```bash
+uv tool install endpaper
+```
+
+### Create a workspace
+
+```bash
+mkdir notes && cd notes
+endpaper init
+```
+
+This creates `.endpaper/config.toml`, `AGENTS.md`, and `meetings/` in the current directory. This directory is now your workspace root — every command below runs from inside it.
+
+### Capture a meeting
+
+```bash
+endpaper meeting new "Q3 planning" --type standup --tag platform
+```
+
+Prints the path to the new file: `meetings/2026-07-28-standup-q3-planning.md`, already stamped with frontmatter (`id`, `type`, `title`, `tags`, `created`, `updated`).
+
+### Browse and list
+
+```bash
+endpaper meeting list --json
+endpaper meeting list --type standup --since 2026-07-01
+```
+
+Or launch the TUI with no arguments:
+
+```bash
+endpaper
+```
+
+![Meetings list and rendered preview](docs/screenshots/meetings.png)
+
+`/` opens a combined filter/command bar — type to filter the list live, or type `meeting.standup <description>` and hit `enter` to create one without leaving the screen. Arrow keys move, `enter` opens the selected meeting in a rendered markdown preview, `e` drops into a raw editor, `ctrl+o`/`ctrl+x` save, `esc` backs out.
+
+![Raw markdown editor with line numbers and frontmatter](docs/screenshots/edit-meeting.png)
+
+### For AI assistants
+
+An assistant working in an endpaper workspace reads `AGENTS.md` at the root and takes it from there — non-interactive, `--json`-capable, and scriptable by design. Nothing opens an editor or blocks on a prompt.
+
+Below, an assistant is asked to pull up a vendor sync meeting, research the competitor options it calls for, and write up its findings — reading and writing the vault the same way it reads and writes a codebase:
+
+![AI assistant reading meeting notes, researching, and writing a new note via the CLI](docs/screenshots/execute-task.png)
+
+The note it produced shows up like any other — because it is:
+
+![The assistant's research note, rendered back in the TUI](docs/screenshots/research-note.png)
+
+See [REQUIREMENTS.md](REQUIREMENTS.md) for the full CLI reference, frontmatter schema, and exit codes.
+
+## Features (v0.0.1)
+
+- **Meeting notes** — `/meeting.standup Q3 planning #platform` creates a dated, frontmatter-tagged file and drops you straight into it. Browse with `/meetings`, filter live, open with `enter`.
+- **General notes** — `/note` opens (or creates) today's daily note; `/note.research vendor landscape #procurement` creates a typed note. Browse with `/notes`.
+- **Tasks** — `/task.followup send the vendor comparison #procurement` appends a checkbox line to `tasks.md`. `/tasks` lists open items; `space` toggles done. The file stays hand-editable plain markdown — no database.
+- **Workspace init** — `endpaper init` sets up a workspace (config, `AGENTS.md`, `meetings/`, `notes/daily/`, `tasks.md`) in the current directory. Multi-user shared workspaces are planned but not in v0.0.1 — see [Roadmap](#roadmap).
+- **View and edit** — every note or meeting opens in a rendered markdown preview (`enter`), switches to a raw editor (`e`) with line numbers and soft wrap, and saves with `ctrl+o` (stay) or `ctrl+x` (save and return). `esc` discards, but only prompts when there's something to lose. `ctrl+s` is also bound as a save alias, but `ctrl+o` is the canonical key: some terminals treat `ctrl+s` as the legacy XOFF flow-control signal and swallow it before it ever reaches endpaper. If saves with `ctrl+s` seem to do nothing, run `stty -ixon` in that shell (or use `ctrl+o` instead).
+- **AI-friendly CLI** — every TUI action has a non-interactive CLI equivalent backed by the same core library: `endpaper find`, `read`, `write`, `append`, `--json` on every read command, meaningful exit codes, nothing that opens an editor or blocks on input.
+- **No index, no database** — the markdown files are the only state. endpaper globs and parses the workspace in memory on launch; nothing to corrupt, nothing to reindex.
+- **`AGENTS.md`** — generated at `init`, under ~60 lines, so an assistant landing in the workspace is productive immediately.
+
+See [REQUIREMENTS.md](REQUIREMENTS.md) for the full v0.0.1 specification, including CLI syntax, frontmatter schema, and acceptance criteria. Not everything above has landed on `main` yet — check [CHANGELOG.md](CHANGELOG.md) for what's actually shipped so far.
+
+## Roadmap
+
+Planned for a future release, tracked in [REQUIREMENTS.md §6](REQUIREMENTS.md#6-backlog--future):
+
+- **Multi-user shared workspaces** — `endpaper init <name>` inside a shared root (e.g. a OneDrive folder), `/workspace` switching, and cross-workspace search, so a team can share one root without a server.
+
+Considered and explicitly out of scope for v0.0.1 (see [REQUIREMENTS.md §5](REQUIREMENTS.md#5-explicitly-out-of-scope-for-v001)):
+
+- AI invocation from inside endpaper (`/claude` markers, SDK integration)
+- Webcam or image capture (`/pic`)
+- Embeddings, vector search, semantic retrieval
+- Tasks created inline from inside a note or meeting
+- Backlinks, wikilinks, graph views
+- Syntax highlighting in the editor
+
+## Status
+
+Draft / pre-release. v0.0.1 targets Python 3.11+, installable via `uv tool install` or `pipx`, on Windows, macOS, and Linux with no network access required.
+
+## License
+
+See [LICENSE](LICENSE).

endpaper-0.0.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+endpaper/__init__.py,sha256=4GZKi13lDTD25YBkGakhZyEQZWTER_OWQMNPoH_UM2c,22
+endpaper/__main__.py,sha256=248zEhKRj3QNlLA-1YuhIXUeKJEtpDk8YqgCX5LdOOk,92
+endpaper/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+endpaper/cli/main.py,sha256=RqDOt6TIKcuJTDGjeEerRizahxCWpTVgUJvJp_AY24Y,10914
+endpaper/cli/output.py,sha256=k4mjxNKFy6h8dZlRIESGnvFEP6Z8cmnSrVyV-W854sk,2245
+endpaper/core/__init__.py,sha256=20vtZVedXzA4r4m0L1_bRAsBQ1hIuGd1FZ0NvrRSWkM,2137
+endpaper/core/documents.py,sha256=BNhkfHUFCEtkYxuqCP6TUireMfhdjZBlpncEzkqt3do,6374
+endpaper/core/editing.py,sha256=uUgyW3H7mWw5HblMUtdm20TchMsniRlgWpKxgGA3ukc,3360
+endpaper/core/errors.py,sha256=SMX4YyVbljQ9L1dMWtXr_qDtoTIpOzsFzSlUTS0viN8,352
+endpaper/core/frontmatter.py,sha256=wITj9jxfhTE8VSmqP4-KcYama-CPghQc_Q60estAW_0,2883
+endpaper/core/meetings.py,sha256=uOWp3d0-xGGoEQehYBHA7mEKks49s8C5urVjZQF9CBc,1034
+endpaper/core/models.py,sha256=BSoPZWa-SOz2LYqobspHbYPOeFWXMo2PDpRHtMpwEpk,2541
+endpaper/core/notes.py,sha256=2KxKgzYoVBYuet9W4JSM1DcBDWk0Va2_3yxaGDPn--Q,1813
+endpaper/core/tasks.py,sha256=nU68897E3urYkKuWqwPlPfr5-n8GjRCwXEiHKLGwTbM,13868
+endpaper/core/text.py,sha256=E8SMlbIz9YY6rM2cAitom0iUWn9sqfzXNdAntsqs9-4,1414
+endpaper/core/workspace.py,sha256=hPLVko-C9h22E7O_9emYkeA0B7wgeJcxD4X6CMBesqs,2910
+endpaper/core/templates/AGENTS.md.tmpl,sha256=U-h1N8ZUQsMjXmlSoccMc2_A4z6ffYHINzL0WaoQmHM,2181
+endpaper/core/templates/CLAUDE.md.tmpl,sha256=Nvcva6XbBG-Q_eYYXBsU4nBh8wPksi-i_t9mEne8awY,404
+endpaper/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+endpaper/tui/app.py,sha256=H6XdC1-Cp9-d7GJTPNNFxP-tTeNc9B-q9okpEnBZAhQ,7261
+endpaper/tui/app.tcss,sha256=3H9N3OiiR6U-ZGzUR4haz7bQh4PlHMMm7RgA-1eYYdA,944
+endpaper/tui/command_bar.py,sha256=6fGft9qxr-Qeouzr88NJTxuNlX0zZRxC6Q1fN3FLcwk,5134
+endpaper/tui/discard_dialog.py,sha256=lAwOnUy7kauSWrOl8DR9hRR6DeQ37lOLQH1Eih3M-Qc,798
+endpaper/tui/edit_screen.py,sha256=uT4am_5XSFjC5SzlXU1rN3j5AFQS2OP0VXRoef1WXfA,3574
+endpaper/tui/list_screen.py,sha256=yVoBHIbxf5MG1_vfHE1ukrWIJzRwO9vm5l_9aDMs6EM,13890
+endpaper/tui/preview_screen.py,sha256=1rvgjwjdI9QpQDt8LueZWh2nTxVIUFGH-o1Fg_ZlMLI,2283
+endpaper/tui/rendering.py,sha256=cFJe1EgHckq8fs3bFhWKjQhtbIsTTmtFpdg-r41GhG0,1458
+endpaper/tui/status_bar.py,sha256=M6N5NqSzcCGp3NDMOnQhCSFQ8moKaefe8WU5VmgnG5U,524
+endpaper-0.0.1.dist-info/METADATA,sha256=azu1xNomCCsAgbwUXCEAk7RxlsTG-2A0b3D-uiHiot4,9436
+endpaper-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+endpaper-0.0.1.dist-info/entry_points.txt,sha256=6tKelpA5b6t77kYhKifvhzA4DzUsIGzuK6_42_rvpjA,52
+endpaper-0.0.1.dist-info/licenses/LICENSE,sha256=K7CTx4RWZFy2NxLZVZEo_yXHb4OPrZB_FU1g64e84nk,1069
+endpaper-0.0.1.dist-info/RECORD,,

endpaper-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

endpaper-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+endpaper = endpaper.cli.main:main