fix(outdated): scope {name} tag patterns to package

When a tag_pattern contains {name}, specialize matching to the target package name so monorepo tags for other packages don't skew outdated results. Also harden parse_tag_version for patterns without {version}.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 2 people

src/apm_cli/commands/marketplace/__init__.py

@@ -1031,7 +1031,11 @@ def _extract_tag_versions(refs, entry, yml, include_prerelease):
     )
 
     def _collect(pattern: str) -> list:
-        tag_rx = build_tag_regex(pattern)
+        tag_rx = (
+            build_tag_regex(pattern, name=entry.name)
+            if "{name}" in pattern
+            else build_tag_regex(pattern)
+        )
         collected = []
         for sv, tag_name, _ in iter_semver_tags(refs, tag_rx):
             if sv.is_prerelease and not (include_prerelease or entry.include_prerelease):

src/apm_cli/commands/outdated.py

@@ -49,16 +49,20 @@ def _resolve_tag_pattern(current_ref: str, package_name: str) -> str | None:
     if inferred:
         return inferred
     if TAG_RE.match(current_ref or ""):
-        return "v{version}" if (current_ref or "").startswith(("v", "V")) else "{version}"
+        return "v{version}" if (current_ref or "").startswith("v") else "{version}"
     return None
 
 
-def _semver_tag_candidates(tag_refs, pattern: str):
+def _semver_tag_candidates(tag_refs, pattern: str, package_name: str = ""):
     """Return ``(SemVer, tag_name)`` pairs matching *pattern*, highest first."""
     from ..marketplace.semver import SemVer, parse_semver
-    from ..marketplace.tag_pattern import build_tag_regex, parse_tag_version
+    from ..marketplace.tag_pattern import build_tag_regex
 
-    tag_rx = build_tag_regex(pattern)
+    tag_rx = (
+        build_tag_regex(pattern, name=package_name)
+        if "{name}" in pattern and package_name
+        else build_tag_regex(pattern)
+    )
     candidates: list[tuple[SemVer, str]] = []
     for remote_ref in tag_refs:
         match = tag_rx.match(remote_ref.name)
@@ -249,7 +253,7 @@ def _check_one_dep(dep, downloader, verbose, registry_ctx=None):
 
         from ..marketplace.tag_pattern import parse_tag_version
 
-        candidates = _semver_tag_candidates(tag_refs, tag_pattern)
+        candidates = _semver_tag_candidates(tag_refs, tag_pattern, package_basename)
         if not candidates:
             return OutdatedRow(
                 package=package_name,
@@ -260,8 +264,12 @@ def _check_one_dep(dep, downloader, verbose, registry_ctx=None):
             )
 
         _, latest_tag = candidates[0]
-        current_ver = parse_tag_version(current_ref, tag_pattern) or _strip_v(current_ref)
-        latest_ver = parse_tag_version(latest_tag, tag_pattern) or _strip_v(latest_tag)
+        current_ver = (
+            parse_tag_version(current_ref, tag_pattern, name=package_basename) or _strip_v(current_ref)
+        )
+        latest_ver = (
+            parse_tag_version(latest_tag, tag_pattern, name=package_basename) or _strip_v(latest_tag)
+        )
 
         if is_newer_version(current_ver, latest_ver):
             extra = [name for _, name in candidates[:10]] if verbose else []

src/apm_cli/marketplace/tag_pattern.py

@@ -67,18 +67,22 @@ def render_tag(pattern: str, *, name: str, version: str) -> str:
     return result
 
 
-def build_tag_regex(pattern: str) -> re.Pattern[str]:
+def build_tag_regex(pattern: str, *, name: str | None = None) -> re.Pattern[str]:
     """Return a compiled regex that captures ``{version}`` from a tag.
 
     Literal text in *pattern* is escaped so that special regex characters
     (e.g. dots, parens) are matched verbatim.  ``{version}`` becomes a
     named capture group ``(?P<version>...)`` matching a semver-like
-    string.  ``{name}`` becomes a non-capturing wildcard ``[^/]+``.
+    string.  ``{name}`` becomes a non-capturing wildcard ``[^/]+``, or
+    the literal *name* when provided (for monorepo per-package tags).
 
     Parameters
     ----------
     pattern:
         Tag pattern string, e.g. ``"v{version}"``.
+    name:
+        When set and the pattern contains ``{name}``, match only this
+        package name instead of any ``[^/]+`` segment.
 
     Returns
     -------
@@ -116,20 +120,28 @@ def build_tag_regex(pattern: str) -> re.Pattern[str]:
     )
 
     escaped = escaped.replace(re.escape(_sentinel_version), _VERSION_RX)
-    escaped = escaped.replace(re.escape(_sentinel_name), r"[^/]+")
+    if _PLACEHOLDER_NAME in pattern and name:
+        name_rx = re.escape(name)
+    else:
+        name_rx = r"[^/]+"
+    escaped = escaped.replace(re.escape(_sentinel_name), name_rx)
 
     return re.compile(r"^" + escaped + r"$")
 
 
 def infer_tag_pattern(tag: str, package_name: str = "") -> str | None:
     """Return the first default pattern that matches *tag*, or ``None``.
 
-    *package_name* is accepted for API symmetry with :func:`render_tag` but
-    is not required for matching because ``{name}`` is a wildcard.
+    When *package_name* is set, patterns containing ``{name}`` only match
+    tags for that package (monorepo-safe).
     """
-    del package_name  # reserved for callers that pass the package display name
     for pattern in DEFAULT_TAG_PATTERNS:
-        if build_tag_regex(pattern).match(tag):
+        rx = (
+            build_tag_regex(pattern, name=package_name)
+            if _PLACEHOLDER_NAME in pattern and package_name
+            else build_tag_regex(pattern)
+        )
+        if rx.match(tag):
             return pattern
     return None
 
@@ -146,12 +158,19 @@ def infer_tag_pattern_from_refs(refs: list, package_name: str = "") -> str | Non
     return None
 
 
-def parse_tag_version(tag: str, pattern: str) -> str | None:
+def parse_tag_version(tag: str, pattern: str, *, name: str | None = None) -> str | None:
     """Extract the semver substring from *tag* using *pattern*."""
-    match = build_tag_regex(pattern).match(tag)
+    if _PLACEHOLDER_VERSION not in pattern:
+        return None
+    rx = (
+        build_tag_regex(pattern, name=name)
+        if _PLACEHOLDER_NAME in pattern and name
+        else build_tag_regex(pattern)
+    )
+    match = rx.match(tag)
     if match is None:
         return None
-    return match.group("version")
+    return match.groupdict().get("version")
 
 
 def is_version_tag_ref(ref: str, package_name: str | None = None) -> bool:

tests/unit/commands/test_marketplace_outdated.py

@@ -116,11 +116,32 @@ def test_infers_name_underscore_v_version_from_remote_tags(self):
         refs = [
             RemoteRef(name="refs/tags/api-governance_v1.0.1", sha=_SHA_A),
             RemoteRef(name="refs/tags/api-governance_v1.0.2", sha=_SHA_B),
+            RemoteRef(name="refs/tags/other-pkg_v9.9.9", sha=_SHA_C),
         ]
         results = _extract_tag_versions(refs, entry, yml, include_prerelease=False)
         tag_names = [tag for _sv, tag in results]
         assert "api-governance_v1.0.1" in tag_names
         assert "api-governance_v1.0.2" in tag_names
+        assert "other-pkg_v9.9.9" not in tag_names
+
+    def test_collect_ignores_other_package_tags_in_monorepo(self):
+        from types import SimpleNamespace
+
+        from apm_cli.commands.marketplace import _extract_tag_versions
+
+        entry = SimpleNamespace(
+            name="apm1",
+            tag_pattern="{name}_v{version}",
+            include_prerelease=False,
+        )
+        yml = SimpleNamespace(build=SimpleNamespace(tag_pattern="v{version}"))
+        refs = [
+            RemoteRef(name="refs/tags/apm1_v1.0.0", sha=_SHA_A),
+            RemoteRef(name="refs/tags/apm2_v1.0.0", sha=_SHA_B),
+        ]
+        results = _extract_tag_versions(refs, entry, yml, include_prerelease=False)
+        tag_names = [tag for _sv, tag in results]
+        assert tag_names == ["apm1_v1.0.0"]
 
 
 # ---------------------------------------------------------------------------

tests/unit/marketplace/test_tag_pattern.py

@@ -159,6 +159,11 @@ def test_name_wildcard_non_greedy(self) -> None:
         assert m is not None
         assert m.group("version") == "2.0.0"
 
+    def test_name_specialized_to_package(self) -> None:
+        rx = build_tag_regex("{name}_v{version}", name="apm1")
+        assert rx.match("apm1_v1.0.0") is not None
+        assert rx.match("apm2_v1.0.0") is None
+
     def test_complex_pattern(self) -> None:
         rx = build_tag_regex("{name}@{version}")
         m = rx.match("tool@3.1.4")
@@ -232,6 +237,10 @@ class TestInferTagPattern:
     def test_name_underscore_v_version(self) -> None:
         assert infer_tag_pattern("api-governance_v1.0.1") == "{name}_v{version}"
 
+    def test_name_underscore_v_scoped_to_package(self) -> None:
+        assert infer_tag_pattern("apm1_v1.0.1", "apm1") == "{name}_v{version}"
+        assert infer_tag_pattern("apm2_v1.0.1", "apm1") is None
+
     def test_name_at_version_not_inferred(self) -> None:
         assert infer_tag_pattern("api-governance@1.0.1") is None
 
@@ -258,7 +267,13 @@ def test_main_is_not_tag(self) -> None:
 
 class TestParseTagVersion:
     def test_name_underscore_v_version(self) -> None:
-        assert parse_tag_version("api-governance_v1.0.1", "{name}_v{version}") == "1.0.1"
+        assert (
+            parse_tag_version("api-governance_v1.0.1", "{name}_v{version}", name="api-governance")
+            == "1.0.1"
+        )
+
+    def test_pattern_without_version_returns_none(self) -> None:
+        assert parse_tag_version("tool-latest", "{name}-latest") is None
 
 
 class TestInferTagPatternFromRefs:

tests/unit/test_outdated_phase3w5.py

@@ -372,6 +372,7 @@ def test_name_underscore_v_version_tag_outdated(self):
         ref_tags = [
             _make_remote_ref("api-governance_v1.0.2", "tag", "sha2"),
             _make_remote_ref("api-governance_v1.0.1", "tag", "sha1"),
+            _make_remote_ref("other-pkg_v9.9.9", "tag", "sha9"),
         ]
         downloader = MagicMock()
         downloader.list_remote_refs.return_value = ref_tags
@@ -388,6 +389,7 @@ def test_name_underscore_v_version_tag_outdated(self):
         assert result.status == "outdated"
         assert result.latest == "api-governance_v1.0.2"
         assert result.source == "git tags"
+        assert "other-pkg" not in (result.latest or "")
 
     def test_tag_no_tags_returns_unknown(self):
         from apm_cli.commands.outdated import _check_one_dep