@stylusnexus/work-plan 2026.6.9 → 2026.6.10

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

@@ -1,7 +1,10 @@
 """Tests for track discovery."""
-import unittest
+import io
 import sys
+import tempfile
+import unittest
 from pathlib import Path
+from unittest.mock import patch
 
 SKILL_ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(SKILL_ROOT))
@@ -10,6 +13,29 @@ from lib.tracks import discover_tracks, discover_archived_tracks
 
 FIXTURES = Path(__file__).parent / "fixtures" / "notes_root"
 
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_git_repo(base: Path) -> Path:
+    """Create a minimal fake git repo at base (has a .git dir)."""
+    (base / ".git").mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def _write_track_md(path: Path, track_name: str, repo: str,
+                    status: str = "active") -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        f"---\ntrack: {track_name}\nstatus: {status}\n"
+        f"github:\n  repo: {repo}\n  issues: []\n---\n\n# {track_name}\n",
+        encoding="utf-8",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Existing private-notes tests (unchanged behaviour)
+# ---------------------------------------------------------------------------
 
 class DiscoverTracksTest(unittest.TestCase):
     def setUp(self):
@@ -38,6 +64,13 @@ class DiscoverTracksTest(unittest.TestCase):
         names = [t.name for t in discover_tracks(self.cfg)]
         self.assertNotIn("old", names)
 
+    def test_private_tracks_tagged_private(self):
+        """All tracks from notes_root carry tier='private'."""
+        tracks = discover_tracks(self.cfg)
+        for t in tracks:
+            self.assertEqual(t.tier, "private",
+                             f"Expected tier='private' for {t.path}")
+
 
 class DiscoverArchivedTracksTest(unittest.TestCase):
     def setUp(self):
@@ -52,5 +85,366 @@ class DiscoverArchivedTracksTest(unittest.TestCase):
         self.assertIn("old", slugs)
 
 
+# ---------------------------------------------------------------------------
+# Shared-notes tier tests
+# ---------------------------------------------------------------------------
+
+class SharedTrackDiscoveryTest(unittest.TestCase):
+    """Shared tracks live in <local>/.work-plan/ and are tagged tier='shared'."""
+
+    def _make_cfg(self, local_clone: Path, notes_root: Path) -> dict:
+        return {
+            "notes_root": str(notes_root),
+            "repos": {
+                "myrepo": {
+                    "github": "org/myrepo",
+                    "local": str(local_clone),
+                },
+            },
+        }
+
+    def test_shared_track_discovered_and_tagged(self):
+        """A track in <local>/.work-plan/ is discovered with tier='shared'."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            wp = clone / ".work-plan" / "myrepo"
+            _write_track_md(wp / "feat-x.md", "feat-x", "org/myrepo")
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = self._make_cfg(clone, notes)
+
+            tracks = discover_tracks(cfg)
+            names = [t.name for t in tracks]
+            self.assertIn("feat-x", names)
+            shared = next(t for t in tracks if t.name == "feat-x")
+            self.assertEqual(shared.tier, "shared")
+
+    def test_shared_track_repo_from_folder_config(self):
+        """repo and local_path on a shared track come from folder config, not frontmatter."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            wp = clone / ".work-plan"
+            _write_track_md(wp / "feat-y.md", "feat-y", "org/myrepo")
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = self._make_cfg(clone, notes)
+
+            tracks = discover_tracks(cfg)
+            t = next(t for t in tracks if t.name == "feat-y")
+            self.assertEqual(t.repo, "org/myrepo")
+            self.assertEqual(
+                str(Path(t.local_path).resolve()),
+                str(clone.resolve()),
+            )
+
+    def test_archive_dir_skipped_by_discover_tracks(self):
+        """Files inside .work-plan/archive/ are excluded from active discovery."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "old.md", "old", "org/myrepo"
+            )
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = self._make_cfg(clone, notes)
+
+            tracks = discover_tracks(cfg)
+            names = [t.name for t in tracks]
+            self.assertNotIn("old", names)
+
+    def test_dotfiles_skipped_in_work_plan(self):
+        """Dotfiles inside .work-plan/ are not discovered."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            wp = clone / ".work-plan"
+            wp.mkdir(parents=True)
+            (wp / ".hidden.md").write_text("---\ntrack: hidden\n---\n", encoding="utf-8")
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = self._make_cfg(clone, notes)
+
+            tracks = discover_tracks(cfg)
+            names = [t.name for t in tracks]
+            self.assertNotIn(".hidden", names)
+
+    def test_readme_skipped_in_work_plan(self):
+        """README.md inside .work-plan/ is not discovered as a track."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            wp = clone / ".work-plan"
+            wp.mkdir(parents=True)
+            (wp / "README.md").write_text("# Notes\n", encoding="utf-8")
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = self._make_cfg(clone, notes)
+
+            tracks = discover_tracks(cfg)
+            names = [t.name for t in tracks]
+            self.assertNotIn("README", names)
+
+    def test_invalid_local_path_contributes_no_tracks(self):
+        """Repos with no/invalid local path produce zero shared tracks."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "noclone": {
+                        "github": "org/noclone",
+                        "local": str(base / "nonexistent"),
+                    },
+                    "nolocal": {
+                        "github": "org/nolocal",
+                        "local": None,
+                    },
+                },
+            }
+            # Should return empty list without raising
+            tracks = discover_tracks(cfg)
+            self.assertEqual(tracks, [])
+
+    def test_non_git_repo_local_contributes_no_tracks(self):
+        """A local path that exists but has no .git/ is skipped silently."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            not_a_repo = base / "notarepo"
+            not_a_repo.mkdir()
+            # Create .work-plan with a track but NO .git dir
+            _write_track_md(
+                not_a_repo / ".work-plan" / "feat.md", "feat", "org/repo"
+            )
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {
+                        "github": "org/repo",
+                        "local": str(not_a_repo),
+                    },
+                },
+            }
+            tracks = discover_tracks(cfg)
+            self.assertEqual(tracks, [])
+
+
+class SharedTrackCollisionTest(unittest.TestCase):
+    """When (repo, name) appears in both shared and private, shared wins + warns."""
+
+    def test_shared_wins_on_collision(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            # Shared track
+            _write_track_md(
+                clone / ".work-plan" / "feat-x.md", "feat-x", "org/repo"
+            )
+            # Private track with SAME name in notes_root
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "feat-x.md", "feat-x", "org/repo"
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            tracks = discover_tracks(cfg)
+            feat_x_tracks = [t for t in tracks if t.name == "feat-x"]
+            # Exactly one track survives the collision
+            self.assertEqual(len(feat_x_tracks), 1)
+            self.assertEqual(feat_x_tracks[0].tier, "shared")
+
+    def test_collision_emits_one_warning(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "feat-x.md", "feat-x", "org/repo"
+            )
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "feat-x.md", "feat-x", "org/repo"
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            with patch("sys.stderr", new_callable=io.StringIO) as mock_err:
+                discover_tracks(cfg)
+                output = mock_err.getvalue()
+            # One warning about the collision
+            self.assertEqual(output.count("WARN:"), 1)
+            self.assertIn("feat-x", output)
+
+
+class SharedTrackSingleOwnerTest(unittest.TestCase):
+    """Frontmatter github.repo that disagrees with folder config → warn, use folder."""
+
+    def test_frontmatter_repo_disagreement_warns_and_uses_folder(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            # Frontmatter says a DIFFERENT repo than the folder config
+            _write_track_md(
+                clone / ".work-plan" / "feat.md", "feat", "wrong/repo"
+            )
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "myrepo": {"github": "correct/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                tracks = discover_tracks(cfg)
+
+            t = next(t for t in tracks if t.name == "feat")
+            # Folder config wins
+            self.assertEqual(t.repo, "correct/repo")
+            # Warning was emitted
+            self.assertIn("WARN:", stderr_buf.getvalue())
+            self.assertIn("correct/repo", stderr_buf.getvalue())
+
+    def test_frontmatter_repo_match_no_warning(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "feat.md", "feat", "correct/repo"
+            )
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "myrepo": {"github": "correct/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                discover_tracks(cfg)
+
+            self.assertNotIn("WARN:", stderr_buf.getvalue())
+
+
+class DiscoverArchivedSharedTest(unittest.TestCase):
+    """discover_archived_tracks also scans shared repos' .work-plan/archive/."""
+
+    def test_shared_archived_track_found(self):
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "shipped.md",
+                "shipped", "org/repo", status="shipped",
+            )
+            notes = base / "notes"
+            notes.mkdir()
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            archived = discover_archived_tracks(cfg)
+            names = [t.name for t in archived]
+            self.assertIn("shipped", names)
+            t = next(t for t in archived if t.name == "shipped")
+            self.assertEqual(t.tier, "shared")
+
+    def test_private_archived_track_still_found(self):
+        """Existing notes_root archives continue to be discovered."""
+        cfg = {
+            "notes_root": str(FIXTURES),
+            "repos": {"critforge": {"github": "stylusnexus/CritForge", "local": None}},
+        }
+        archived = discover_archived_tracks(cfg)
+        slugs = [a.meta.get("track") for a in archived]
+        self.assertIn("old", slugs)
+
+    def test_archived_collision_shared_wins(self):
+        """When (repo, name) collides in archived tracks, shared wins + warns."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            # Shared archived track
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "shipped.md",
+                "shipped", "org/repo", status="shipped",
+            )
+            # Private archived track with SAME name in notes_root
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "archive" / "shipped.md",
+                "shipped", "org/repo", status="shipped",
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                archived = discover_archived_tracks(cfg)
+
+            # Exactly one entry for "shipped"
+            shipped = [t for t in archived if t.name == "shipped"]
+            self.assertEqual(len(shipped), 1)
+            self.assertEqual(shipped[0].tier, "shared")
+            # Warning was emitted
+            self.assertIn("WARN:", stderr_buf.getvalue())
+            self.assertIn("shipped", stderr_buf.getvalue())
+
+    def test_archived_no_collision_no_warning(self):
+        """Different names in shared/private archives → no warning, both returned."""
+        with tempfile.TemporaryDirectory() as d:
+            base = Path(d)
+            clone = _make_git_repo(base / "clone")
+            _write_track_md(
+                clone / ".work-plan" / "archive" / "shared-archived.md",
+                "shared-archived", "org/repo", status="shipped",
+            )
+            notes = base / "notes"
+            _write_track_md(
+                notes / "repo" / "archive" / "private-archived.md",
+                "private-archived", "org/repo", status="shipped",
+            )
+            cfg = {
+                "notes_root": str(notes),
+                "repos": {
+                    "repo": {"github": "org/repo", "local": str(clone)},
+                },
+            }
+
+            stderr_buf = io.StringIO()
+            with patch("sys.stderr", stderr_buf):
+                archived = discover_archived_tracks(cfg)
+
+            names = [t.name for t in archived]
+            self.assertIn("shared-archived", names)
+            self.assertIn("private-archived", names)
+            self.assertNotIn("WARN:", stderr_buf.getvalue())
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -378,5 +378,140 @@ class WhereWasINoSessionLogCase(unittest.TestCase):
         self.assertIn("Last session: (none yet)", out)
 
 
+class OrientRepoFlagTest(unittest.TestCase):
+    """orient command --repo=<key> and track@repo disambiguation."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.notes_root = Path(self.tmp.name) / "notes_root"
+        self.notes_root.mkdir(parents=True)
+        # Create two tracks with the same slug in different repos
+        for folder in ("repo-a", "repo-b"):
+            repo_dir = self.notes_root / folder
+            repo_dir.mkdir(parents=True)
+            _make_track_file(repo_dir, slug="feat-x")
+
+        self.cfg = {
+            "notes_root": str(self.notes_root),
+            "repos": {
+                "repo-a": {"github": "org/repo-a"},
+                "repo-b": {"github": "org/repo-b"},
+            },
+        }
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def _drive(self, args, *, find_result=None):
+        """Drive orient.run() with load_config mocked. If find_result is None
+        (the normal case), discover_tracks runs for real against tmp files.
+        When find_result is an Exception, we mock find_track_by_name."""
+        patches = [
+            mock.patch("commands.where_was_i.load_config", return_value=self.cfg),
+            mock.patch("commands.where_was_i.fetch_issues", return_value=[]),
+            mock.patch("commands.where_was_i.find_new_issues_for_tracks",
+                       return_value={}),
+            mock.patch("commands.where_was_i.current_branch", return_value=None),
+            mock.patch("commands.where_was_i.commits_ahead", return_value=0),
+            mock.patch("commands.where_was_i.uncommitted_file_count", return_value=0),
+        ]
+        if find_result is not None:
+            patches.append(
+                mock.patch("commands.where_was_i.find_track_by_name",
+                           side_effect=find_result
+                           if isinstance(find_result, Exception)
+                           else None,
+                           return_value=find_result
+                           if not isinstance(find_result, Exception)
+                           else None)
+            )
+
+        for p in patches:
+            p.start()
+
+        try:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = where_was_i.run(args)
+            return rc, buf.getvalue()
+        finally:
+            for p in patches:
+                p.stop()
+
+    def test_repo_flag_passed_to_find_track(self):
+        """--repo=<key> is passed as repo= kwarg to find_track_by_name."""
+        find_mock = mock.MagicMock()
+        find_mock.return_value = None  # We just care about how it was called
+
+        patches = [
+            mock.patch("commands.where_was_i.load_config", return_value=self.cfg),
+            mock.patch("commands.where_was_i.find_track_by_name", find_mock),
+            mock.patch("commands.where_was_i.discover_tracks", return_value=[]),
+            mock.patch("commands.where_was_i.fetch_issues", return_value=[]),
+            mock.patch("commands.where_was_i.find_new_issues_for_tracks",
+                       return_value={}),
+            mock.patch("commands.where_was_i.current_branch", return_value=None),
+            mock.patch("commands.where_was_i.commits_ahead", return_value=0),
+            mock.patch("commands.where_was_i.uncommitted_file_count", return_value=0),
+        ]
+        for p in patches:
+            p.start()
+        try:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                where_was_i.run(["feat-x", "--repo=repo-a"])
+        finally:
+            for p in patches:
+                p.stop()
+
+        call_kwargs = find_mock.call_args.kwargs
+        self.assertEqual(call_kwargs.get("repo"), "repo-a")
+
+    def test_at_syntax_passed_to_find_track(self):
+        """feat-x@repo-a positional → repo='repo-a' passed to find_track_by_name."""
+        find_mock = mock.MagicMock()
+        find_mock.return_value = None
+
+        patches = [
+            mock.patch("commands.where_was_i.load_config", return_value=self.cfg),
+            mock.patch("commands.where_was_i.find_track_by_name", find_mock),
+            mock.patch("commands.where_was_i.discover_tracks", return_value=[]),
+            mock.patch("commands.where_was_i.fetch_issues", return_value=[]),
+            mock.patch("commands.where_was_i.find_new_issues_for_tracks",
+                       return_value={}),
+            mock.patch("commands.where_was_i.current_branch", return_value=None),
+            mock.patch("commands.where_was_i.commits_ahead", return_value=0),
+            mock.patch("commands.where_was_i.uncommitted_file_count", return_value=0),
+        ]
+        for p in patches:
+            p.start()
+        try:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                where_was_i.run(["feat-x@repo-a"])
+        finally:
+            for p in patches:
+                p.stop()
+
+        call_kwargs = find_mock.call_args.kwargs
+        self.assertEqual(call_kwargs.get("repo"), "repo-a")
+
+    def test_ambiguous_error_returns_rc1(self):
+        """AmbiguousTrackError → prints message, returns 1."""
+        from lib.tracks import Track, AmbiguousTrackError
+
+        t1 = Track(path=Path("/tmp/fake/repo-a/feat-x.md"), name="feat-x",
+                   has_frontmatter=True, needs_init=False, needs_filing=False,
+                   repo="org/a", folder="repo-a", meta={"track": "feat-x", "status": "active"})
+        t2 = Track(path=Path("/tmp/fake/repo-b/feat-x.md"), name="feat-x",
+                   has_frontmatter=True, needs_init=False, needs_filing=False,
+                   repo="org/b", folder="repo-b", meta={"track": "feat-x", "status": "active"})
+        err = AmbiguousTrackError("feat-x", [t1, t2])
+
+        rc, out = self._drive(["feat-x"], find_result=err)
+        self.assertEqual(rc, 1)
+        self.assertIn("ambiguous", out.lower())
+
+
 if __name__ == "__main__":
     unittest.main()