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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: td-task
-Version: 0.2.1
+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

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

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

@@ -1,5 +1,10 @@
 # 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.

{td_task-0.2.1 → 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.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()