td-task 0.2.0__tar.gz → 0.2.1__tar.gz

{td_task-0.2.0 → td_task-0.2.1}/.github/workflows/publish.yml

@@ -8,7 +8,13 @@ on:
 
 jobs:
   deploy:
+    name: Publish distribution to PyPI
     runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/td-task/
+    permissions:
+      id-token: write
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -16,9 +22,6 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
 
-      - name: Install Doppler CLI
-        uses: dopplerhq/cli-action@v3
-
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
@@ -28,6 +31,6 @@ jobs:
         run: uv build
 
       - name: Publish to PyPI
-        run: doppler run -- sh -c 'UV_PUBLISH_TOKEN="$PYPI_API" uv publish'
-        env:
-          DOPPLER_TOKEN: ${{ secrets.DOPPLER_TOKEN }}
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # release/v1
+        with:
+          skip-existing: true

{td_task-0.2.0 → td_task-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: td-task
-Version: 0.2.0
+Version: 0.2.1
 Summary: Fast TUI and CLI manager for tasks and Markdown notes
 Requires-Python: >=3.14
 Requires-Dist: cryptography>=42.0.0
@@ -28,6 +28,17 @@ Or with pip:
 pip install td-task
 ```
 
+## Local publishing environment
+
+PyPI credentials live in the ignored `.env` file. The encrypted backup is
+`.env.enc`.
+
+```nu
+^age --decrypt .env.enc | save --force .env
+```
+
+Never print decrypted secrets or commit `.env`.
+
 Run directly without installing:
 
 ```bash

{td_task-0.2.0 → td_task-0.2.1}/README.md

@@ -17,6 +17,17 @@ Or with pip:
 pip install td-task
 ```
 
+## Local publishing environment
+
+PyPI credentials live in the ignored `.env` file. The encrypted backup is
+`.env.enc`.
+
+```nu
+^age --decrypt .env.enc | save --force .env
+```
+
+Never print decrypted secrets or commit `.env`.
+
 Run directly without installing:
 
 ```bash

{td_task-0.2.0 → td_task-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "td-task"
-version = "0.2.0"
+version = "0.2.1"
 description = "Fast TUI and CLI manager for tasks and Markdown notes"
 readme = "README.md"
 requires-python = ">=3.14"

{td_task-0.2.0 → td_task-0.2.1}/src/td/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.2.1] - 2026-08-04
+- Soft-wrap long note lines to terminal width without changing stored Markdown.
+- Keep Markdown preview styling across wrapped rows and scroll with the active cursor.
+
 ## [0.2.0] - 2026-08-03
 - Add task-backed Markdown notes with a full-screen editor and live line preview.
 - Add `A` to create notes, `e`/`Enter` to edit note bodies, and `E` to rename notes.

{td_task-0.2.0 → td_task-0.2.1}/src/td/tui.py

@@ -573,6 +573,78 @@ def _bullet_line_parts(source: str) -> tuple[str, str, str] | None:
     return match.group(1), match.group(2), match.group(3)
 
 
+def _wrap_editor_text(source: Text, width: int) -> list[Text]:
+    """Soft-wrap styled text without changing or dropping source characters."""
+    from rich.cells import cell_len
+
+    width = max(1, width)
+    plain = source.plain
+    if not plain:
+        return [Text()]
+
+    offsets: list[tuple[int, int]] = []
+    start = 0
+    while start < len(plain):
+        end = start
+        used = 0
+        last_break: int | None = None
+        has_content = False
+
+        while end < len(plain):
+            char_width = cell_len(plain[end])
+            if end > start and used + char_width > width:
+                break
+            used += char_width
+            end += 1
+            if plain[end - 1].isspace() and has_content:
+                last_break = end
+            elif not plain[end - 1].isspace():
+                has_content = True
+            if used >= width:
+                break
+
+        if end < len(plain) and last_break is not None and last_break > start:
+            end = last_break
+        if end == start:
+            end += 1
+
+        offsets.append((start, end))
+        start = end
+
+    return [source[start:end] for start, end in offsets]
+
+
+def _note_editor_visual_rows(
+    lines: list[str],
+    active_row: int,
+    column: int,
+    content_width: int,
+) -> tuple[list[tuple[int, int, Text]], int]:
+    """Build wrapped display rows and return the active cursor row index."""
+    visual_rows: list[tuple[int, int, Text]] = []
+    cursor_visual_row = 0
+
+    for line_index, line in enumerate(lines):
+        if line_index == active_row:
+            rendered = Text(line, style="cyan bold")
+            if column < len(line):
+                rendered.stylize("reverse cyan bold", column, column + 1)
+            else:
+                rendered.append(" ", style="reverse cyan bold")
+            wrapped = _wrap_editor_text(rendered, content_width)
+        else:
+            wrapped = _wrap_editor_text(_markdown_preview_line(line), content_width)
+
+        for segment_index, segment in enumerate(wrapped):
+            visual_rows.append((line_index, segment_index, segment))
+            if line_index == active_row and any(
+                "reverse" in str(span.style) for span in segment.spans
+            ):
+                cursor_visual_row = len(visual_rows) - 1
+
+    return visual_rows, cursor_visual_row
+
+
 def _render_note_editor(
     title: str,
     lines: list[str],
@@ -592,28 +664,21 @@ def _render_note_editor(
     console.print(Text("─" * width, style="dim"), end="\033[K\n")
 
     visible_rows = max(3, height - 6)
-    end = min(len(lines), scroll + visible_rows)
     number_width = max(2, len(str(len(lines))))
     content_width = max(10, width - number_width - 5)
+    visual_rows, _ = _note_editor_visual_rows(lines, row, column, content_width)
+    visible = visual_rows[scroll:scroll + visible_rows]
 
-    for line_index in range(scroll, end):
-        prefix = f"{'▸' if line_index == row else ' '} {line_index + 1:>{number_width}} │ "
-        line = lines[line_index]
-        output = Text(prefix, style="cyan bold" if line_index == row else "dim")
-        if line_index == row:
-            offset = max(0, column - content_width + 1)
-            visible = line[offset:offset + content_width]
-            visible_column = column - offset
-            output.append(visible[:visible_column], style="cyan bold")
-            char_under = visible[visible_column] if visible_column < len(visible) else " "
-            output.append(char_under, style="reverse cyan bold")
-            if visible_column < len(visible):
-                output.append(visible[visible_column + 1:], style="cyan bold")
+    for line_index, segment_index, segment in visible:
+        if segment_index == 0:
+            prefix = f"{'▸' if line_index == row else ' '} {line_index + 1:>{number_width}} │ "
         else:
-            output.append(_markdown_preview_line(line))
+            prefix = f"  {'':>{number_width}} │ "
+        output = Text(prefix, style="cyan bold" if line_index == row else "dim")
+        output.append(segment)
         console.print(output, end="\033[K\n", overflow="crop", no_wrap=True)
 
-    for _ in range(visible_rows - (end - scroll)):
+    for _ in range(visible_rows - len(visible)):
         console.print(end="\033[K\n")
 
     footer = "  Esc:save & close │ Ctrl+S:save │ Enter:new line │ arrows:move"
@@ -643,10 +708,14 @@ def _run_note_editor(note_id: int) -> None:
 
     while True:
         visible_rows = max(3, (console.height or 24) - 6)
-        if row < scroll:
-            scroll = row
-        elif row >= scroll + visible_rows:
-            scroll = row - visible_rows + 1
+        width = max(30, console.width or 80)
+        number_width = max(2, len(str(len(lines))))
+        content_width = max(10, width - number_width - 5)
+        _, cursor_visual_row = _note_editor_visual_rows(lines, row, column, content_width)
+        if cursor_visual_row < scroll:
+            scroll = cursor_visual_row
+        elif cursor_visual_row >= scroll + visible_rows:
+            scroll = cursor_visual_row - visible_rows + 1
         _render_note_editor(note["title"], lines, row, column, scroll, status_msg)
         status_msg = ""
         key = term.read_key()

{td_task-0.2.0 → td_task-0.2.1}/tests/test_tui_notes.py

@@ -6,7 +6,9 @@ import unittest
 from pathlib import Path
 from unittest.mock import patch
 
+from rich.cells import cell_len
 from rich.console import Console
+from rich.text import Text
 
 from td import db, terminal, tui
 
@@ -100,6 +102,52 @@ class NoteTuiTests(unittest.TestCase):
         self.assertIn("bold", str(inline.spans[0].style))
         self.assertIn("italic", str(inline.spans[1].style))
 
+    def test_note_editor_wrap_preserves_every_character(self) -> None:
+        source = Text("alpha  beta gamma-supercalifragilistic", style="bold")
+        wrapped = tui._wrap_editor_text(source, 8)
+
+        self.assertEqual("".join(part.plain for part in wrapped), source.plain)
+        self.assertTrue(all(cell_len(part.plain) <= 8 for part in wrapped))
+        self.assertTrue(all("bold" in str(part.style) for part in wrapped))
+
+    def test_note_editor_cursor_follows_wrapped_line(self) -> None:
+        line = "one two three four five six"
+        visual_rows, cursor_row = tui._note_editor_visual_rows(
+            [line], 0, len(line), 7
+        )
+
+        self.assertGreater(len(visual_rows), 1)
+        self.assertEqual(visual_rows[cursor_row][0], 0)
+        self.assertTrue(any(
+            "reverse" in str(span.style)
+            for span in visual_rows[cursor_row][2].spans
+        ))
+
+    def test_note_editor_scroll_tracks_wrapped_cursor(self) -> None:
+        note = db.add_note("Wrapping")
+        assert note is not None
+        db.update_note_content(note["id"], "word " * 40)
+        scroll_positions: list[int] = []
+        test_console = Console(file=io.StringIO(), width=30, height=10, force_terminal=False)
+        keys = iter([terminal.KEY_END, terminal.KEY_ESC])
+
+        with (
+            patch.object(tui, "console", test_console),
+            patch.object(terminal, "read_key", side_effect=lambda: next(keys)),
+            patch.object(terminal, "clear_screen"),
+            patch.object(
+                tui,
+                "_render_note_editor",
+                side_effect=lambda _title, _lines, _row, _column, scroll, _status: (
+                    scroll_positions.append(scroll)
+                ),
+            ),
+        ):
+            tui._run_note_editor(note["id"])
+
+        self.assertEqual(scroll_positions[0], 0)
+        self.assertGreater(scroll_positions[-1], 0)
+
     def test_alt_arrows_move_editor_lines(self) -> None:
         note = db.add_note("Movement")
         assert note is not None

{td_task-0.2.0 → td_task-0.2.1}/uv.lock

@@ -142,7 +142,7 @@ wheels = [
 
 [[package]]
 name = "td-task"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },