@stylusnexus/work-plan 2026.6.9 → 2026.6.10

package/skills/work-plan/tests/test_init_shared.py

@@ -0,0 +1,185 @@
+"""Tests for init command on shared (.work-plan/) paths — Phase C."""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import init
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_cfg(*, notes_root="/tmp/fake-notes", repos=None):
+    if repos is None:
+        repos = {
+            "myrepo": {
+                "github": "org/myrepo",
+                "local": "/home/user/projects/myrepo",
+            }
+        }
+    return {"notes_root": notes_root, "repos": repos}
+
+
+def _drive_shared(args, *, cfg=None, body="", vis="PRIVATE",
+                  path_str=None, meta=None):
+    """Run init.run on a path inside a .work-plan/ directory.
+
+    Uses paths that are already absolute and canonical (no symlink resolution
+    needed) and patches expanduser/resolve so they return the path unchanged.
+    Config local paths match the fake clone root exactly.
+    """
+    if cfg is None:
+        cfg = _make_cfg()
+    if path_str is None:
+        path_str = "/home/user/projects/myrepo/.work-plan/my-track.md"
+    fake_path = Path(path_str)
+    existing_meta = meta if meta is not None else {}
+
+    # Patch expanduser to be a no-op and resolve to return self, so Path
+    # comparisons inside _find_repo_for_shared_path use the literal strings
+    # we put in cfg["repos"][...]["local"].
+    _orig_expanduser = Path.expanduser
+    _orig_resolve = Path.resolve
+
+    def _noop_expanduser(self):
+        return self
+
+    def _noop_resolve(self):
+        return self
+
+    with patch("commands.init.load_config", return_value=cfg), \
+         patch("commands.init.parse_file", return_value=(existing_meta, body)), \
+         patch("commands.init.write_file") as mw, \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("pathlib.Path.exists", return_value=True), \
+         patch("pathlib.Path.expanduser", _noop_expanduser), \
+         patch("pathlib.Path.resolve", _noop_resolve):
+        full_args = [str(fake_path)] + list(args)
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = init.run(full_args)
+    return rc, mw, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class InitSharedPathTest(unittest.TestCase):
+
+    def test_shared_path_resolves_repo_from_config(self):
+        """init on a .work-plan/ path resolves github repo from config entry."""
+        rc, mw, out = _drive_shared([], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        written_meta = mw.call_args[0][1]
+        self.assertEqual(written_meta["github"]["repo"], "org/myrepo")
+
+    def test_shared_path_never_writes_tbd(self):
+        """init on a .work-plan/ path never writes github.repo == 'TBD'."""
+        rc, mw, out = _drive_shared([], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        written_meta = mw.call_args[0][1]
+        self.assertNotEqual(written_meta["github"]["repo"], "TBD")
+
+    def test_shared_path_prints_tier_shared(self):
+        """init on a .work-plan/ path prints 'tier: shared'."""
+        rc, mw, out = _drive_shared([], vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        self.assertIn("tier: shared", out)
+
+    def test_shared_path_unregistered_repo_returns_rc1(self):
+        """init on a .work-plan/ dir not in config → error, rc 1."""
+        # Config has no matching local path
+        cfg = _make_cfg(repos={
+            "other": {
+                "github": "org/other",
+                "local": "/home/user/projects/other",
+            }
+        })
+        rc, mw, out = _drive_shared([], cfg=cfg, vis="PRIVATE")
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertIn("ERROR", out)
+        self.assertIn("init-repo", out)
+
+    def test_shared_path_already_has_frontmatter_no_write(self):
+        """init on a .work-plan/ path that already has frontmatter → no write, rc 0."""
+        existing = {"track": "my-track", "status": "active"}
+        rc, mw, out = _drive_shared([], meta=existing, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("already has frontmatter", out)
+
+    def test_shared_path_body_issue_refs_captured(self):
+        """init on a .work-plan/ path scans body for issue refs."""
+        body = "Implements #42 and #99.\n"
+        rc, mw, out = _drive_shared([], body=body, vis="PRIVATE")
+        self.assertEqual(rc, 0)
+        written_meta = mw.call_args[0][1]
+        self.assertEqual(written_meta["github"]["issues"], [42, 99])
+
+    def test_shared_path_public_repo_requires_confirm(self):
+        """init on a .work-plan/ path with PUBLIC repo → needs_confirm JSON, no write."""
+        rc, mw, out = _drive_shared([], vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        import json
+        data = json.loads(out.strip())
+        self.assertTrue(data["needs_confirm"])
+
+
+def _noop_expanduser(self):
+    return self
+
+
+def _noop_resolve(self):
+    return self
+
+
+class InitFindRepoHelperTest(unittest.TestCase):
+    """Unit tests for _find_repo_for_shared_path.
+
+    Use expanduser/resolve no-op patches so that literal path strings in cfg
+    compare equal to the Path objects derived from the track path.
+    """
+
+    def test_finds_registered_repo(self):
+        """_find_repo_for_shared_path returns github slug for registered clone."""
+        cfg = _make_cfg()
+        path = Path("/home/user/projects/myrepo/.work-plan/some-track.md")
+        with patch("pathlib.Path.expanduser", _noop_expanduser), \
+             patch("pathlib.Path.resolve", _noop_resolve):
+            result = init._find_repo_for_shared_path(path, cfg)
+        self.assertEqual(result, "org/myrepo")
+
+    def test_returns_none_for_unregistered_clone(self):
+        """_find_repo_for_shared_path returns None when clone not in config."""
+        cfg = _make_cfg(repos={
+            "other": {"github": "org/other", "local": "/home/user/projects/other"},
+        })
+        path = Path("/home/user/projects/myrepo/.work-plan/some-track.md")
+        with patch("pathlib.Path.expanduser", _noop_expanduser), \
+             patch("pathlib.Path.resolve", _noop_resolve):
+            result = init._find_repo_for_shared_path(path, cfg)
+        self.assertIsNone(result)
+
+    def test_returns_none_for_non_shared_path(self):
+        """_find_repo_for_shared_path returns None for a path not in .work-plan/."""
+        cfg = _make_cfg()
+        path = Path("/tmp/fake-notes/myrepo/some-track.md")
+        # No patches needed — the path doesn't have .work-plan in parts,
+        # so the function returns None before calling expanduser/resolve.
+        result = init._find_repo_for_shared_path(path, cfg)
+        self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_list_sort.py

@@ -0,0 +1,162 @@
+"""Tests for the `list --sort` flag (issue #181).
+
+Covers:
+- --sort=recent orders active tracks by last_touched descending.
+- Tracks missing last_touched sort LAST under --sort=recent.
+- --sort=priority orders P0→P3 with last_touched recency as tiebreaker;
+  tracks missing launch_priority sort after those that have it.
+- Default (no --sort) preserves discovery (filesystem) order exactly.
+- --all still appends the archived section, and works alongside --sort.
+- An invalid --sort value (or bare --sort) returns rc 2.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import list_cmd
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(name, *, repo="ok/repo", status="active", priority=None, last_touched=None):
+    meta = {"track": name, "status": status}
+    if priority is not None:
+        meta["launch_priority"] = priority
+    if last_touched is not None:
+        meta["last_touched"] = last_touched
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body="# fake",
+        meta=meta,
+        has_frontmatter=True,
+        needs_init=False,
+        needs_filing=False,
+        repo=repo,
+    )
+
+
+def _drive(args, tracks, archived=None):
+    """Run list_cmd.run(args) with config + discovery mocked. Returns (rc, output)."""
+    cfg = {"notes_root": "/tmp/fake-notes", "repos": {}}
+    with patch("commands.list_cmd.load_config", return_value=cfg), \
+         patch("commands.list_cmd.discover_tracks", return_value=tracks), \
+         patch("commands.list_cmd.discover_archived_tracks", return_value=archived or []):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = list_cmd.run(args)
+    return rc, buf.getvalue()
+
+
+def _order(output, names):
+    """Return the names from `names` in the order they appear in output."""
+    positions = [(output.index(n), n) for n in names if n in output]
+    return [n for _, n in sorted(positions)]
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class ListSortTest(unittest.TestCase):
+
+    def test_sort_recent_orders_by_last_touched_desc(self):
+        """--sort=recent orders tracks most-recently-touched first."""
+        tracks = [
+            _track("old", last_touched="2026-01-01"),
+            _track("newest", last_touched="2026-06-01"),
+            _track("middle", last_touched="2026-03-15"),
+        ]
+        rc, out = _drive(["--sort=recent"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["old", "newest", "middle"]),
+                         ["newest", "middle", "old"])
+
+    def test_sort_recent_missing_last_touched_sorts_last(self):
+        """Tracks with no last_touched sort after those that have one."""
+        tracks = [
+            _track("nodate"),
+            _track("dated", last_touched="2026-05-01"),
+        ]
+        rc, out = _drive(["--sort=recent"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["nodate", "dated"]), ["dated", "nodate"])
+
+    def test_sort_priority_orders_p0_to_p3_with_recency_tiebreak(self):
+        """--sort=priority orders P0→P3; equal priority breaks by recency."""
+        tracks = [
+            _track("p2", priority="P2", last_touched="2026-01-01"),
+            _track("p0", priority="P0", last_touched="2026-01-01"),
+            _track("p1_old", priority="P1", last_touched="2026-01-01"),
+            _track("p1_new", priority="P1", last_touched="2026-06-01"),
+        ]
+        rc, out = _drive(["--sort=priority"], tracks)
+        self.assertEqual(rc, 0)
+        # P0 first, then P1 (newest of the two first), then P2
+        self.assertEqual(
+            _order(out, ["p0", "p1_new", "p1_old", "p2"]),
+            ["p0", "p1_new", "p1_old", "p2"],
+        )
+
+    def test_sort_priority_missing_priority_sorts_after_known(self):
+        """Tracks missing launch_priority sort after those that have it."""
+        tracks = [
+            _track("none"),
+            _track("p3", priority="P3"),
+            _track("p0", priority="P0"),
+        ]
+        rc, out = _drive(["--sort=priority"], tracks)
+        self.assertEqual(rc, 0)
+        self.assertEqual(_order(out, ["none", "p3", "p0"]), ["p0", "p3", "none"])
+
+    def test_default_preserves_discovery_order(self):
+        """No --sort flag preserves the exact filesystem discovery order."""
+        tracks = [
+            _track("zebra", priority="P3", last_touched="2026-01-01"),
+            _track("alpha", priority="P0", last_touched="2026-06-01"),
+            _track("mango", priority="P1", last_touched="2026-03-01"),
+        ]
+        rc, out = _drive([], tracks)
+        self.assertEqual(rc, 0)
+        # Discovery order is preserved despite priority/recency differences.
+        self.assertEqual(_order(out, ["zebra", "alpha", "mango"]),
+                         ["zebra", "alpha", "mango"])
+
+    def test_all_appends_archived_section_with_sort(self):
+        """--all still appends the Archived section alongside --sort."""
+        tracks = [
+            _track("recent_active", last_touched="2026-06-01"),
+            _track("old_active", last_touched="2026-01-01"),
+        ]
+        archived = [_track("done_track", status="shipped")]
+        rc, out = _drive(["--all", "--sort=recent"], tracks, archived=archived)
+        self.assertEqual(rc, 0)
+        self.assertIn("Archived:", out)
+        self.assertIn("done_track", out)
+        # Active section still recency-sorted, and archived comes after.
+        self.assertLess(out.index("recent_active"), out.index("old_active"))
+        self.assertLess(out.index("old_active"), out.index("Archived:"))
+
+    def test_invalid_sort_value_returns_rc2(self):
+        """An unrecognized --sort value returns rc 2 (usage error)."""
+        rc, out = _drive(["--sort=bogus"], [_track("a")])
+        self.assertEqual(rc, 2)
+        self.assertIn("usage", out)
+
+    def test_bare_sort_flag_returns_rc2(self):
+        """--sort with no value returns rc 2."""
+        rc, out = _drive(["--sort"], [_track("a")])
+        self.assertEqual(rc, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_move.py

@@ -0,0 +1,240 @@
+"""Tests for the move subcommand (issue #162).
+
+Covers:
+- Moves an issue from source track to destination track (two writes).
+- Issue not in source → error, rc 1.
+- Cross-repo guard → error, rc 1.
+- Same-track no-op → rc 0, message.
+- Already in destination → remove from source only, rc 0.
+- Public repo confirm gate → prints needs_confirm JSON, rc 0.
+- Public repo with valid --confirm=<token> → writes, rc 0.
+- Bad args → rc 2.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import move
+from lib.write_guard import make_token
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _track(*, name, repo="ok/repo", issues=None, status="active"):
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body="# fake",
+        meta={
+            "track": name,
+            "status": status,
+            "github": {"repo": repo, "issues": list(issues or [])},
+        },
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+def _drive(args, tracks=None, vis="PRIVATE"):
+    """Run move.run(args) with all external I/O mocked."""
+    if tracks is None:
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[]),
+        ]
+    cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/repo"}}}
+
+    with patch("commands.move.load_config", return_value=cfg), \
+         patch("commands.move.discover_tracks", return_value=tracks), \
+         patch("lib.write_guard.repo_visibility", return_value=vis), \
+         patch("commands.move.write_file") as mw:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = move.run(args)
+    return rc, mw, buf.getvalue()
+
+
+# ---------------------------------------------------------------------------
+# Test cases
+# ---------------------------------------------------------------------------
+
+class MoveBasicTest(unittest.TestCase):
+
+    def test_moves_issue_from_source_to_destination(self):
+        """Move #42 from alpha to beta: both tracks written."""
+        tracks = [
+            _track(name="alpha", issues=[42, 99]),
+            _track(name="beta", issues=[7]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 0)
+        self.assertIn("Removed #42 from 'alpha'", out)
+        self.assertIn("Added #42 to 'beta'", out)
+        # Two writes: source then destination
+        self.assertEqual(mw.call_count, 2)
+
+        # Source: 42 removed, 99 remains
+        source_call = mw.call_args_list[0]
+        source_issues = source_call[0][1]["github"]["issues"]
+        self.assertNotIn(42, source_issues)
+        self.assertIn(99, source_issues)
+
+        # Destination: 42 added, 7 remains, sorted
+        dest_call = mw.call_args_list[1]
+        dest_issues = dest_call[0][1]["github"]["issues"]
+        self.assertIn(42, dest_issues)
+        self.assertIn(7, dest_issues)
+        self.assertEqual(dest_issues, sorted(dest_issues))
+
+    def test_issue_not_in_source_errors(self):
+        """#999 is not in alpha → rc 1, error message."""
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[]),
+        ]
+        rc, mw, out = _drive(["999", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 1)
+        self.assertIn("not in track", out)
+        mw.assert_not_called()
+
+    def test_cross_repo_move_errors(self):
+        """Moving between different repos is rejected."""
+        tracks = [
+            _track(name="alpha", repo="ok/repo", issues=[42]),
+            _track(name="beta", repo="other/repo", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 1)
+        self.assertIn("cross-repo", out)
+        mw.assert_not_called()
+
+    def test_same_track_noop(self):
+        """Moving to the same track is a no-op."""
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "alpha"], tracks=tracks)
+        self.assertEqual(rc, 0)
+        self.assertIn("already in track", out)
+        mw.assert_not_called()
+
+    def test_already_in_destination_removes_from_source_only(self):
+        """#42 already in beta → remove from alpha, don't re-add to beta."""
+        tracks = [
+            _track(name="alpha", issues=[42, 99]),
+            _track(name="beta", issues=[42, 7]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 0)
+        self.assertIn("already in track 'beta'", out)
+        self.assertIn("Removed #42 from 'alpha'", out)
+        # Only one write (source only, dest unchanged)
+        self.assertEqual(mw.call_count, 1)
+
+        call = mw.call_args_list[0]
+        source_issues = call[0][1]["github"]["issues"]
+        self.assertNotIn(42, source_issues)
+        self.assertIn(99, source_issues)
+
+    def test_bad_args_usage(self):
+        """Less than 3 positional args → rc 2."""
+        rc, mw, out = _drive(["42", "alpha"])
+        self.assertEqual(rc, 2)
+        self.assertIn("usage:", out)
+        mw.assert_not_called()
+
+    def test_non_numeric_issue_errors(self):
+        """Non-numeric issue number → rc 2."""
+        rc, mw, out = _drive(["abc", "alpha", "beta"])
+        self.assertEqual(rc, 2)
+        self.assertIn("not an issue number", out)
+        mw.assert_not_called()
+
+
+class MovePublicRepoTest(unittest.TestCase):
+
+    def test_public_repo_prints_needs_confirm(self):
+        """Public repo without --confirm prints needs_confirm JSON."""
+        tracks = [
+            _track(name="alpha", repo="ok/repo", issues=[42]),
+            _track(name="beta", repo="ok/repo", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks, vis="PUBLIC")
+        self.assertEqual(rc, 0)
+        self.assertIn('"needs_confirm": true', out)
+        self.assertIn('"token":', out)
+        mw.assert_not_called()
+
+    def test_public_repo_with_valid_confirm_writes(self):
+        """Public repo with valid --confirm=<token> writes successfully."""
+        tracks = [
+            _track(name="alpha", repo="ok/repo", issues=[42]),
+            _track(name="beta", repo="ok/repo", issues=[]),
+        ]
+        token = make_token("ok/repo", "beta")
+        rc, mw, out = _drive(
+            ["42", "alpha", "beta", f"--confirm={token}"],
+            tracks=tracks,
+            vis="PUBLIC",
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("Removed #42 from 'alpha'", out)
+        self.assertIn("Added #42 to 'beta'", out)
+        self.assertEqual(mw.call_count, 2)
+
+    def test_private_repo_no_token_writes_directly(self):
+        """Private repo writes without any confirm gate."""
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 0)
+        self.assertIn("Removed", out)
+        self.assertIn("Added", out)
+        self.assertEqual(mw.call_count, 2)
+
+
+class MoveTrackResolutionTest(unittest.TestCase):
+
+    def test_no_active_track_matching(self):
+        """Inactive or nonexistent source track → rc 1."""
+        tracks = [
+            _track(name="alpha", issues=[42], status="shipped"),
+            _track(name="beta", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 1)
+        self.assertIn("No active track matching", out)
+
+    def test_no_active_destination(self):
+        """Inactive destination track → rc 1."""
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[], status="shipped"),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 1)
+        self.assertIn("No active track matching", out)
+
+    def test_issue_already_in_archived_track(self):
+        """Moving from an active track even if issue is also in a shipped track."""
+        tracks = [
+            _track(name="alpha", issues=[42]),
+            _track(name="beta", issues=[]),
+        ]
+        rc, mw, out = _drive(["42", "alpha", "beta"], tracks=tracks)
+        self.assertEqual(rc, 0)
+        self.assertIn("Removed", out)
+        self.assertIn("Added", out)
+        self.assertEqual(mw.call_count, 2)