@stylusnexus/work-plan 2026.6.9

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()