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

{td_task-0.2.0 → td_task-0.2.2}/.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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: td-task
-Version: 0.2.0
+Version: 0.2.2
 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.2}/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.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "td-task"
-version = "0.2.0"
+version = "0.2.2"
 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.2}/src/td/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.2.2] - 2026-08-05
+- Fix `td update` silently reporting "already up-to-date" on installs made from a local checkout.
+- Pull the source checkout with `git pull --ff-only` and force a rebuild before upgrading such installs.
+- Abort the update instead of rebuilding stale code when the pull fails.
+
+## [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.2}/src/td/__main__.py

@@ -393,13 +393,72 @@ def _run_list(list_name: str) -> None:
     console.print(Text("─" * width, style="dim"))
 
 
+def _source_checkout() -> str | None:
+    """Return the git checkout td was installed from, or None for a PyPI install."""
+    import subprocess
+    import tomllib
+
+    try:
+        result = subprocess.run(
+            ["uv", "tool", "dir"], capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode != 0:
+            return None
+        receipt = os.path.join(result.stdout.strip(), "td-task", "uv-receipt.toml")
+        with open(receipt, "rb") as f:
+            data = tomllib.load(f)
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return None
+
+    for requirement in data.get("tool", {}).get("requirements", []):
+        directory = requirement.get("directory")
+        if directory and os.path.isdir(os.path.join(directory, ".git")):
+            return directory
+    return None
+
+
+def _source_version(source_dir: str) -> str | None:
+    """Read the version declared by the source checkout's pyproject.toml."""
+    import tomllib
+
+    try:
+        with open(os.path.join(source_dir, "pyproject.toml"), "rb") as f:
+            return tomllib.load(f).get("project", {}).get("version")
+    except (OSError, ValueError):
+        return None
+
+
 def _run_update() -> None:
-    """Update td to the latest version from PyPI."""
+    """Update td to the latest version, from the local checkout when installed from one."""
     import subprocess
+    from importlib.metadata import version as _pkg_version
+
+    upgrade_cmd = ["uv", "tool", "upgrade", "td-task"]
+    source_dir = _source_checkout()
+
+    if source_dir:
+        print(f"Pulling latest source from {source_dir}...")
+        pull = subprocess.run(
+            ["git", "-C", source_dir, "pull", "--ff-only"],
+            capture_output=True, text=True, timeout=60,
+        )
+        if pull.returncode != 0:
+            print(f"✗ git pull failed: {pull.stderr.strip()}")
+            sys.exit(1)
+        try:
+            installed = _pkg_version("td-task")
+        except Exception:
+            installed = None
+        if installed and _source_version(source_dir) == installed:
+            print("already up-to-date.")
+            return
+        # A path install keeps resolving to the same requirement, so uv reports
+        # nothing to upgrade unless the rebuild is forced.
+        upgrade_cmd.append("--reinstall")
+
     print("Updating td...")
     result = subprocess.run(
-        ["uv", "tool", "upgrade", "td-task"],
-        capture_output=True, text=True, timeout=60,
+        upgrade_cmd, capture_output=True, text=True, timeout=300,
     )
     if result.returncode == 0:
         output = (result.stdout + result.stderr).strip()

{td_task-0.2.0 → td_task-0.2.2}/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.2}/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.2/tests/test_update.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import io
+import subprocess
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch
+
+from td.__main__ import _run_update, _source_checkout, _source_version
+
+
+def _completed(args, returncode=0, stdout="", stderr=""):
+    return subprocess.CompletedProcess(args, returncode, stdout, stderr)
+
+
+class SourceCheckoutTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp_dir.name)
+        self.checkout = self.root / "src-checkout"
+        (self.checkout / ".git").mkdir(parents=True)
+        self.tool_dir = self.root / "tools"
+        (self.tool_dir / "td-task").mkdir(parents=True)
+
+    def tearDown(self) -> None:
+        self.temp_dir.cleanup()
+
+    def _write_receipt(self, body: str) -> None:
+        (self.tool_dir / "td-task" / "uv-receipt.toml").write_text(body, encoding="utf-8")
+
+    def _tool_dir_call(self, *args, **kwargs):
+        return _completed(args, stdout=f"{self.tool_dir}\n")
+
+    def test_detects_directory_install(self) -> None:
+        self._write_receipt(
+            f'[tool]\nrequirements = [{{ name = "td-task", directory = "{self.checkout}" }}]\n'
+        )
+        with patch("subprocess.run", side_effect=self._tool_dir_call):
+            self.assertEqual(_source_checkout(), str(self.checkout))
+
+    def test_pypi_install_has_no_checkout(self) -> None:
+        self._write_receipt('[tool]\nrequirements = [{ name = "td-task" }]\n')
+        with patch("subprocess.run", side_effect=self._tool_dir_call):
+            self.assertIsNone(_source_checkout())
+
+    def test_directory_without_git_is_ignored(self) -> None:
+        plain = self.root / "not-a-repo"
+        plain.mkdir()
+        self._write_receipt(
+            f'[tool]\nrequirements = [{{ name = "td-task", directory = "{plain}" }}]\n'
+        )
+        with patch("subprocess.run", side_effect=self._tool_dir_call):
+            self.assertIsNone(_source_checkout())
+
+    def test_missing_receipt_returns_none(self) -> None:
+        with patch("subprocess.run", side_effect=self._tool_dir_call):
+            self.assertIsNone(_source_checkout())
+
+    def test_source_version_read_from_pyproject(self) -> None:
+        (self.checkout / "pyproject.toml").write_text(
+            '[project]\nname = "td-task"\nversion = "9.9.9"\n', encoding="utf-8"
+        )
+        self.assertEqual(_source_version(str(self.checkout)), "9.9.9")
+
+    def test_source_version_missing_pyproject(self) -> None:
+        self.assertIsNone(_source_version(str(self.checkout)))
+
+
+class RunUpdateTests(unittest.TestCase):
+    def test_source_install_pulls_before_rebuilding(self) -> None:
+        calls = []
+
+        def fake_run(args, **kwargs):
+            calls.append(args)
+            return _completed(args)
+
+        with patch("td.__main__._source_checkout", return_value="/repo"), \
+                patch("td.__main__._source_version", return_value="0.3.0"), \
+                patch("td.__main__._print_changelog"), \
+                patch("importlib.metadata.version", return_value="0.2.9"), \
+                patch("subprocess.run", side_effect=fake_run), \
+                redirect_stdout(io.StringIO()):
+            _run_update()
+
+        self.assertEqual(calls[0], ["git", "-C", "/repo", "pull", "--ff-only"])
+        self.assertEqual(calls[1], ["uv", "tool", "upgrade", "td-task", "--reinstall"])
+
+    def test_source_install_skips_rebuild_when_current(self) -> None:
+        calls = []
+
+        def fake_run(args, **kwargs):
+            calls.append(args)
+            return _completed(args)
+
+        buffer = io.StringIO()
+        with patch("td.__main__._source_checkout", return_value="/repo"), \
+                patch("td.__main__._source_version", return_value="0.2.9"), \
+                patch("importlib.metadata.version", return_value="0.2.9"), \
+                patch("subprocess.run", side_effect=fake_run), \
+                redirect_stdout(buffer):
+            _run_update()
+
+        self.assertEqual(calls, [["git", "-C", "/repo", "pull", "--ff-only"]])
+        self.assertIn("already up-to-date", buffer.getvalue())
+
+    def test_failed_pull_aborts_without_rebuilding(self) -> None:
+        calls = []
+
+        def fake_run(args, **kwargs):
+            calls.append(args)
+            return _completed(args, returncode=1, stderr="divergent branches")
+
+        buffer = io.StringIO()
+        with patch("td.__main__._source_checkout", return_value="/repo"), \
+                patch("subprocess.run", side_effect=fake_run), \
+                redirect_stdout(buffer):
+            with self.assertRaises(SystemExit):
+                _run_update()
+
+        self.assertEqual(calls, [["git", "-C", "/repo", "pull", "--ff-only"]])
+        self.assertIn("divergent branches", buffer.getvalue())
+
+    def test_pypi_install_upgrades_without_pull(self) -> None:
+        calls = []
+
+        def fake_run(args, **kwargs):
+            calls.append(args)
+            return _completed(args, stdout="Nothing to upgrade")
+
+        with patch("td.__main__._source_checkout", return_value=None), \
+                patch("subprocess.run", side_effect=fake_run), \
+                redirect_stdout(io.StringIO()):
+            _run_update()
+
+        self.assertEqual(calls, [["uv", "tool", "upgrade", "td-task"]])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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