@stylusnexus/work-plan 2026.6.9-1

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_llm_evidence.py

@@ -0,0 +1,77 @@
+"""Tests for LLM candidate selection + evidence gathering."""
+import unittest
+import sys
+import tempfile
+from datetime import date, datetime
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.llm_evidence import select_candidates, gather_evidence, EXCERPT_CHARS
+
+
+def _row(rel, verdict, present, declared):
+    return {"rel": rel, "verdict": verdict, "files_present": present,
+            "files_declared": declared, "glyph": "?", "rationale": ""}
+
+
+class SelectCandidatesTest(unittest.TestCase):
+    def test_picks_manifest_less(self):
+        rows = [_row("a.md", "manifest-less", 0, 0)]
+        self.assertEqual([r["rel"] for r in select_candidates(rows)], ["a.md"])
+
+    def test_picks_ambiguous_low_completion(self):
+        rows = [_row("b.md", "partial", 0, 38), _row("c.md", "partial", 1, 11)]
+        picked = {r["rel"] for r in select_candidates(rows)}
+        self.assertEqual(picked, {"b.md", "c.md"})
+
+    def test_skips_confident_shipped_and_healthy_partial(self):
+        rows = [_row("d.md", "shipped", 9, 9), _row("e.md", "partial", 8, 12)]
+        self.assertEqual(select_candidates(rows), [])
+
+
+class GatherEvidenceTest(unittest.TestCase):
+    def test_builds_evidence_dict(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            (root / "docs").mkdir()
+            doc_path = root / "docs/x-design.md"
+            doc_path.write_text("# Design X\n\nLong prose. " + "z" * 5000)
+
+            class Doc:
+                path = doc_path
+                rel = "docs/x-design.md"
+                kind = "spec"
+
+            fake_dt = datetime(2026, 4, 2, 10, 0, 0)
+            with mock.patch("lib.llm_evidence.git_state.path_last_commit_date",
+                            return_value=fake_dt):
+                ev = gather_evidence(Doc(), root)
+            self.assertEqual(ev["rel"], "docs/x-design.md")
+            self.assertEqual(ev["kind"], "spec")
+            self.assertEqual(ev["last_touched"], "2026-04-02")
+            self.assertEqual(ev["title"], "Design X")
+            self.assertLessEqual(len(ev["excerpt"]), EXCERPT_CHARS)
+
+    def test_none_last_touched(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = Path(d)
+            doc_path = root / "y.md"
+            doc_path.write_text("no heading\n")
+
+            class Doc:
+                path = doc_path
+                rel = "y.md"
+                kind = "adhoc"
+
+            with mock.patch("lib.llm_evidence.git_state.path_last_commit_date",
+                            return_value=None):
+                ev = gather_evidence(Doc(), root)
+            self.assertIsNone(ev["last_touched"])
+            self.assertEqual(ev["title"], "(no title)")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,162 @@
+"""Tests for manifest parsing + scoring."""
+import unittest
+import sys
+from datetime import date
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.manifest import (
+    DeclaredPath, strip_range, parse_declared_paths,
+    count_checkboxes, plan_date_from_filename,
+    ManifestScore, score_manifest,
+    is_in_tree, out_of_tree_ratio,
+)
+
+
+class InTreeTest(unittest.TestCase):
+    ROOT = Path("/repo")
+
+    def test_relative_is_in_tree(self):
+        self.assertTrue(is_in_tree("src/foo.ts", self.ROOT))
+
+    def test_tilde_is_out_of_tree(self):
+        self.assertFalse(is_in_tree("~/.claude/skills/x.py", self.ROOT))
+
+    def test_absolute_elsewhere_is_out_of_tree(self):
+        self.assertFalse(is_in_tree("/Applications/other/x.ts", self.ROOT))
+
+    def test_absolute_under_root_is_in_tree(self):
+        self.assertTrue(is_in_tree("/repo/src/x.ts", self.ROOT))
+
+    def test_dotdot_escape_is_out_of_tree(self):
+        self.assertFalse(is_in_tree("../sibling/x.ts", self.ROOT))
+
+
+class OutOfTreeRatioTest(unittest.TestCase):
+    def test_all_foreign(self):
+        decls = [DeclaredPath("create", "~/.claude/a.py"),
+                 DeclaredPath("create", "/Applications/other/b.ts")]
+        self.assertEqual(out_of_tree_ratio(decls, Path("/repo")), 1.0)
+
+    def test_mixed(self):
+        decls = [DeclaredPath("create", "src/a.ts"),
+                 DeclaredPath("create", "~/b.py")]
+        self.assertEqual(out_of_tree_ratio(decls, Path("/repo")), 0.5)
+
+    def test_empty_is_zero(self):
+        self.assertEqual(out_of_tree_ratio([], Path("/repo")), 0.0)
+
+
+class StripRangeTest(unittest.TestCase):
+    def test_strips_line_range(self):
+        self.assertEqual(strip_range("src/foo.ts:120-145"), "src/foo.ts")
+
+    def test_strips_single_line(self):
+        self.assertEqual(strip_range("src/foo.ts:12"), "src/foo.ts")
+
+    def test_strips_multi_range(self):
+        self.assertEqual(strip_range("src/foo.tsx:104-115,217-247"), "src/foo.tsx")
+
+    def test_leaves_bare_path(self):
+        self.assertEqual(strip_range("src/foo.ts"), "src/foo.ts")
+
+
+class ParseDeclaredPathsTest(unittest.TestCase):
+    SAMPLE = (
+        "**Files:**\n"
+        "- Create: `src/lib/idea.ts`\n"
+        "- Modify: `src/app/route.ts:10-22`\n"
+        "- Test: `tests/idea.test.ts`\n"
+        "Run: `npm test`\n"            # not a declared path (no Create/Modify/Test)
+        "See `SomeType` for details\n"  # not a path
+    )
+
+    def test_extracts_three_kinds(self):
+        decls = parse_declared_paths(self.SAMPLE)
+        kinds = {d.kind for d in decls}
+        self.assertEqual(kinds, {"create", "modify", "test"})
+
+    def test_strips_range_on_modify(self):
+        decls = parse_declared_paths(self.SAMPLE)
+        modify = [d for d in decls if d.kind == "modify"][0]
+        self.assertEqual(modify.path, "src/app/route.ts")
+
+    def test_ignores_non_declaration_backticks(self):
+        decls = parse_declared_paths(self.SAMPLE)
+        paths = {d.path for d in decls}
+        self.assertNotIn("npm test", paths)
+        self.assertNotIn("SomeType", paths)
+
+    def test_dedupes_first_kind_wins(self):
+        text = "- Create: `a/b.ts`\n- Modify: `a/b.ts`\n"
+        decls = parse_declared_paths(text)
+        self.assertEqual(len(decls), 1)
+        self.assertEqual(decls[0].kind, "create")
+
+
+class CountCheckboxesTest(unittest.TestCase):
+    def test_counts_done_and_total_multiline(self):
+        text = "- [x] one\n- [ ] two\n  - [X] three\n- [ ] four\n"
+        done, total = count_checkboxes(text)
+        self.assertEqual((done, total), (2, 4))
+
+    def test_no_checkboxes(self):
+        self.assertEqual(count_checkboxes("plain prose"), (0, 0))
+
+
+class PlanDateTest(unittest.TestCase):
+    def test_extracts_iso_prefix(self):
+        self.assertEqual(plan_date_from_filename("2026-03-16-idea-mode-ui.md"),
+                         date(2026, 3, 16))
+
+    def test_returns_none_without_date(self):
+        self.assertIsNone(plan_date_from_filename("idea-mode-ui.md"))
+
+
+class ScoreManifestTest(unittest.TestCase):
+    def _decls(self):
+        return [
+            DeclaredPath("create", "src/new.ts"),
+            DeclaredPath("create", "src/missing.ts"),
+            DeclaredPath("modify", "src/existing.ts"),
+            DeclaredPath("test", "tests/new.test.ts"),
+        ]
+
+    def test_scores_with_injected_predicates(self):
+        present = {"src/new.ts", "tests/new.test.ts", "src/existing.ts"}
+        committed = {"src/existing.ts"}
+        score = score_manifest(
+            self._decls(), Path("/repo"), date(2026, 3, 1),
+            exists=lambda rel: rel in present,
+            committed_since=lambda rel: rel in committed,
+        )
+        # create: new.ts present(yes), missing.ts(no) -> 1/2
+        # modify: existing.ts committed-since(yes) -> 1/1
+        # test:   new.test.ts present(yes) -> 1/1
+        self.assertEqual(score.total, 4)
+        self.assertEqual(score.satisfied, 3)
+        self.assertEqual(score.by_kind["create"], (1, 2))
+        self.assertEqual(score.by_kind["modify"], (1, 1))
+        self.assertEqual(score.by_kind["test"], (1, 1))
+        self.assertAlmostEqual(score.pct, 75.0)
+
+    def test_modify_existing_but_not_committed_is_unsatisfied(self):
+        score = score_manifest(
+            [DeclaredPath("modify", "src/old.ts")], Path("/repo"), date(2026, 3, 1),
+            exists=lambda rel: True,             # file exists...
+            committed_since=lambda rel: False,   # ...but untouched since plan date
+        )
+        self.assertEqual(score.satisfied, 0)
+
+    def test_empty_manifest_pct_none(self):
+        score = score_manifest([], Path("/repo"), None,
+                               exists=lambda rel: False,
+                               committed_since=lambda rel: False)
+        self.assertEqual(score.total, 0)
+        self.assertIsNone(score.pct)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,130 @@
+"""Tests for new-issue matching."""
+import unittest
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.new_issues import build_slug_labels, match_issue_to_tracks
+
+
+class MatchIssueTest(unittest.TestCase):
+    def test_label_match_wins(self):
+        issue = {"number": 9, "title": "unrelated", "labels": [{"name": "track/tabletop"}]}
+        matches = match_issue_to_tracks(issue, ["tabletop", "ux-redesign"])
+        self.assertEqual(matches, ["tabletop"])
+
+    def test_keyword_in_title(self):
+        issue = {"number": 10, "title": "fix tabletop initiative tracker", "labels": []}
+        matches = match_issue_to_tracks(issue, ["tabletop", "ux-redesign"])
+        self.assertEqual(matches, ["tabletop"])
+
+    def test_no_match_returns_empty(self):
+        issue = {"number": 11, "title": "boring thing", "labels": []}
+        self.assertEqual(match_issue_to_tracks(issue, ["tabletop", "ux-redesign"]), [])
+
+    def test_multiple_matches(self):
+        issue = {"number": 12, "title": "tabletop ux redesign for combat", "labels": []}
+        matches = match_issue_to_tracks(issue, ["tabletop", "ux-redesign"])
+        self.assertEqual(set(matches), {"tabletop", "ux-redesign"})
+
+    def test_slug_labels_override_single(self):
+        # Repo uses flat label `storytelling` instead of `track/storytelling-enhancements`.
+        issue = {"number": 100, "title": "unrelated", "labels": [{"name": "storytelling"}]}
+        slug_labels = {"storytelling-enhancements": ["storytelling"]}
+        matches = match_issue_to_tracks(issue, ["storytelling-enhancements"],
+                                        slug_labels=slug_labels)
+        self.assertEqual(matches, ["storytelling-enhancements"])
+
+    def test_slug_labels_override_multiple_or_semantics(self):
+        # Track configured to match if EITHER label is present (OR semantics).
+        slug_labels = {"ai-generators": ["ai", "generators"]}
+
+        issue_a = {"number": 200, "title": "x", "labels": [{"name": "ai"}]}
+        self.assertEqual(
+            match_issue_to_tracks(issue_a, ["ai-generators"], slug_labels=slug_labels),
+            ["ai-generators"],
+        )
+
+        issue_b = {"number": 201, "title": "x", "labels": [{"name": "generators"}]}
+        self.assertEqual(
+            match_issue_to_tracks(issue_b, ["ai-generators"], slug_labels=slug_labels),
+            ["ai-generators"],
+        )
+
+        issue_c = {"number": 202, "title": "x", "labels": [{"name": "unrelated"}]}
+        self.assertEqual(
+            match_issue_to_tracks(issue_c, ["ai-generators"], slug_labels=slug_labels),
+            [],
+        )
+
+    def test_default_track_slug_label_still_works_when_other_track_overrides(self):
+        # Two tracks: one overridden, one using default `track/<slug>`.
+        slug_labels = {"storytelling-enhancements": ["storytelling"]}
+        issue = {"number": 300, "title": "unrelated", "labels": [{"name": "track/tabletop"}]}
+        matches = match_issue_to_tracks(
+            issue, ["storytelling-enhancements", "tabletop"], slug_labels=slug_labels
+        )
+        self.assertEqual(matches, ["tabletop"])
+
+    def test_type_label_does_not_leak_into_track_match(self):
+        # A `type:feature` label on its own should NOT auto-match a track
+        # unless a track explicitly opts into it via slug_labels.
+        issue = {
+            "number": 400,
+            "title": "boring thing",
+            "labels": [{"name": "type:feature"}, {"name": "priority:P3"}],
+        }
+        # No slug_labels override → default behaviour, no match.
+        self.assertEqual(match_issue_to_tracks(issue, ["tabletop"]), [])
+        # Explicit opt-in for one track → that track matches.
+        slug_labels = {"feature-work": ["type:feature"]}
+        matches = match_issue_to_tracks(
+            issue, ["feature-work", "tabletop"], slug_labels=slug_labels
+        )
+        self.assertEqual(matches, ["feature-work"])
+
+
+class BuildSlugLabelsTest(unittest.TestCase):
+    def _track(self, slug, labels=None, has_fm=True):
+        meta = {"track": slug}
+        if labels is not None:
+            meta["github"] = {"labels": labels}
+        return SimpleNamespace(name=slug, has_frontmatter=has_fm, meta=meta)
+
+    def test_extracts_labels_from_frontmatter(self):
+        tracks = [
+            self._track("storytelling-enhancements", ["storytelling"]),
+            self._track("ai-generators", ["ai", "generators"]),
+        ]
+        result = build_slug_labels(tracks)
+        self.assertEqual(result, {
+            "storytelling-enhancements": ["storytelling"],
+            "ai-generators": ["ai", "generators"],
+        })
+
+    def test_omits_tracks_without_labels(self):
+        # Tracks without `github.labels` are absent from the map; callers fall
+        # back to the default `track/<slug>` pattern for those.
+        tracks = [
+            self._track("tabletop"),  # no labels
+            self._track("storytelling-enhancements", ["storytelling"]),
+        ]
+        result = build_slug_labels(tracks)
+        self.assertEqual(result, {"storytelling-enhancements": ["storytelling"]})
+
+    def test_skips_tracks_without_frontmatter(self):
+        tracks = [
+            self._track("ghost", ["foo"], has_fm=False),
+        ]
+        self.assertEqual(build_slug_labels(tracks), {})
+
+    def test_strips_blank_label_entries(self):
+        tracks = [self._track("foo", ["a", "  ", ""])]
+        self.assertEqual(build_slug_labels(tracks), {"foo": ["a"]})
+
+
+if __name__ == "__main__":
+    unittest.main()