Refactor changelog package resolution to use get_targeted_directories

Per review feedback on #46016, route package discovery through the shared
Check.get_targeted_directories pipeline used by import_all and other
azpysdk checks instead of custom discover_targeted_packages / walk-up logic.

Behavior changes:
- add/create/status now inherit the common 'target' positional (default '**').
- Subdirectory walk-up is dropped: run from package root with '.' or pass the
  package path/name explicitly.
- verify is unchanged (always repo-level, no target).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: l0lawrence

eng/tools/azure-sdk-tools/azpysdk/changelog.py

@@ -6,9 +6,7 @@
 from typing import Optional, List
 
 from .Check import Check, REPO_ROOT
-from ci_tools.functions import discover_targeted_packages
 from ci_tools.logging import logger
-from ci_tools.parsing import ParsedSetup
 
 # The expected Chronus package name and on-disk install location.
 # Chronus is pinned as a dev dependency in .github/chronus/package.json with
@@ -63,10 +61,14 @@ def register(
     ) -> None:
         """Register the ``changelog`` command group.
 
-        The *parent_parsers* (common args like ``target``, ``--isolate``) are
-        intentionally **not** used here because changelog commands operate at
-        the repository level via Chronus, not on individual packages.
+        ``add``, ``create``, and ``status`` inherit the shared
+        ``target`` positional (and related common args) from
+        *parent_parsers* so that package resolution goes through the same
+        :meth:`Check.get_targeted_directories` pipeline used by
+        ``import_all`` and the other ``azpysdk`` checks.  ``verify``
+        always operates at the repo level, so it does not take a target.
         """
+        parents = parent_parsers or []
         p = subparsers.add_parser(
             "changelog",
             help="Manage changelogs with Chronus (add, verify, create, status)",
@@ -76,16 +78,8 @@ def register(
         changelog_sub = p.add_subparsers(title="changelog commands", dest="changelog_command")
 
         # changelog add
-        add_p = changelog_sub.add_parser("add", help="Add a chronus change entry for modified packages")
-        add_p.add_argument(
-            "package",
-            nargs="?",
-            default=None,
-            help=(
-                "Package path (e.g. sdk/storage/azure-storage-blob) to add an entry for. "
-                "If omitted and CWD is inside a package directory, the package is detected "
-                "automatically. Otherwise chronus detects modified packages interactively."
-            ),
+        add_p = changelog_sub.add_parser(
+            "add", parents=parents, help="Add a chronus change entry for modified packages"
         )
         add_p.add_argument(
             "--kind",
@@ -102,37 +96,19 @@ def register(
         )
         add_p.set_defaults(func=self._run_add)
 
-        # changelog verify
+        # changelog verify (operates on the whole repo; no target)
         verify_p = changelog_sub.add_parser("verify", help="Verify all modified packages have change entries")
         verify_p.set_defaults(func=self._run_verify)
 
         # changelog create
-        create_p = changelog_sub.add_parser("create", help="Generate CHANGELOG.md from pending chronus entries")
-        create_p.add_argument(
-            "package",
-            nargs="?",
-            default=None,
-            help=(
-                "Package path (e.g. sdk/storage/azure-storage-blob) to generate changelog for. "
-                "If omitted and CWD is inside a package directory, the package is detected "
-                "automatically. Otherwise chronus generates changelogs for all packages."
-            ),
+        create_p = changelog_sub.add_parser(
+            "create", parents=parents, help="Generate CHANGELOG.md from pending chronus entries"
         )
         create_p.set_defaults(func=self._run_create)
 
         # changelog status
         status_p = changelog_sub.add_parser(
-            "status", help="Show a summary of pending changes and resulting version bumps"
-        )
-        status_p.add_argument(
-            "package",
-            nargs="?",
-            default=None,
-            help=(
-                "Package path (e.g. sdk/storage/azure-storage-blob) to show status for. "
-                "If omitted and CWD is inside a package directory, the package is detected "
-                "automatically. Otherwise chronus shows status for all packages."
-            ),
+            "status", parents=parents, help="Show a summary of pending changes and resulting version bumps"
         )
         status_p.set_defaults(func=self._run_status)
 
@@ -213,58 +189,32 @@ def _ensure_chronus_installed(self) -> None:
             )
             raise SystemExit(1)
 
-    def _find_package_root_from_cwd(self) -> Optional[str]:
-        """Find the package root directory when CWD is at or below ``sdk/<service>/<package>``.
-
-        Walks up from the current directory to locate the package root,
-        unlike ``get_targeted_directories(target=".")`` which only works
-        when CWD is exactly the package root.  This lets developers run
-        changelog commands from subdirectories such as
-        ``sdk/core/azure-core/tests/``.
-
-        Returns the absolute path to the package root, or ``None`` if CWD
-        is not inside an ``sdk/<service>/<package>`` tree.
-        """
-        try:
-            cwd = os.path.abspath(os.getcwd())
-            repo = os.path.abspath(REPO_ROOT)
-            rel = os.path.relpath(cwd, repo)
-        except ValueError:
-            # On Windows, relpath raises ValueError when paths are on different drives
-            return None
+    def _resolve_package(self, args: argparse.Namespace) -> Optional[str]:
+        """Resolve ``args`` to a single Chronus package name.
 
-        parts = rel.replace("\\", "/").split("/")
-        if len(parts) >= 3 and parts[0] == "sdk":
-            return os.path.join(repo, parts[0], parts[1], parts[2])
-        return None
+        Delegates to :meth:`Check.get_targeted_directories` — the same
+        discovery pipeline used by ``import_all`` and the other
+        ``azpysdk`` checks.  The first discovered package's name is
+        returned (matching chronus's single-package model).
 
-    def _resolve_package(self, package_arg: Optional[str]) -> Optional[str]:
-        """Resolve a package argument or CWD to a Chronus package name.
+        Returns ``None`` when:
 
-        Uses ``discover_targeted_packages`` — the same discovery function
-        that powers ``get_targeted_directories`` — to locate packages by
-        path or bare name.  When *package_arg* is ``None``, the method
-        detects the package from CWD by walking up to the nearest
-        ``sdk/<service>/<package>`` directory.
+        * ``args.target`` is unset or left at the default glob ``"**"``
+          — the user hasn't scoped to a package, so chronus runs without
+          a package argument (interactive / whole-repo mode).
+        * No package is discovered for the provided target (e.g.
+          ``target="."`` from a directory that isn't a package root).
         """
-        if package_arg:
-            found = discover_targeted_packages(package_arg, REPO_ROOT)
-            if found:
-                try:
-                    return ParsedSetup.from_path(found[0]).name
-                except Exception:
-                    return os.path.basename(found[0])
-            # Not found by discovery — pass through as-is
-            return package_arg
-
-        # No explicit package — detect from CWD
-        pkg_root = self._find_package_root_from_cwd()
-        if pkg_root is None:
+        target = getattr(args, "target", None)
+        if not target or target == "**":
             return None
         try:
-            return ParsedSetup.from_path(pkg_root).name
+            targeted = self.get_targeted_directories(args)
         except Exception:
-            return os.path.basename(os.path.normpath(pkg_root))
+            return None
+        if not targeted:
+            return None
+        return targeted[0].name
 
     def _run_chronus(self, chronus_args: List[str]) -> int:
         """Run a chronus command from the repository root.
@@ -286,21 +236,21 @@ def _run_chronus(self, chronus_args: List[str]) -> int:
     # ------------------------------------------------------------------
 
     def _run_add(self, args: argparse.Namespace) -> int:
-        """Run ``chronus add`` to interactively add a change entry.
-
-        When no *package* argument is given but CWD is inside a package
-        directory (``sdk/<service>/<package>``), the package path is detected
-        automatically so the developer doesn't have to specify it.
-
-        Optional ``--kind`` and ``--message`` flags are forwarded to chronus
-        so the developer can skip the interactive prompts (e.g.
-        ``azpysdk changelog add --kind breaking -m "Removed foo API"``).
+        """Run ``chronus add`` to add a change entry.
+
+        Uses :meth:`_resolve_package` to resolve ``args.target`` to a
+        specific Chronus package when one is provided (explicit path,
+        bare name, or ``.`` from the package root).  When no target is
+        given (default glob ``**``), chronus is invoked without a
+        package argument so it can detect modified packages
+        interactively.
+
+        Optional ``--kind`` and ``--message`` flags are forwarded to
+        chronus so the developer can skip the interactive prompts
+        (e.g. ``azpysdk changelog add . --kind breaking -m "Removed foo API"``).
         """
         chronus_args = ["add"]
-        detected_from_cwd = not args.package
-        package = self._resolve_package(args.package)
-        if package and detected_from_cwd:
-            logger.info(f"Detected package from current directory: {package}")
+        package = self._resolve_package(args)
         if package:
             chronus_args.append(package)
 
@@ -319,21 +269,19 @@ def _run_verify(self, args: argparse.Namespace) -> int:
     def _run_create(self, args: argparse.Namespace) -> int:
         """Run ``chronus changelog`` to generate CHANGELOG.md files.
 
-        When no *package* argument is given but CWD is inside a package
-        directory, the package path is detected automatically and passed
-        via ``--package`` so only that package's changelog is generated.
+        Requires a package to be resolvable from ``args.target`` (via
+        :meth:`_resolve_package`).  Run from the package root with ``.``
+        or pass the package path/name explicitly.
         """
         chronus_args = ["changelog"]
-        detected_from_cwd = not args.package
-        package = self._resolve_package(args.package)
-        if package and detected_from_cwd:
-            logger.info(f"Detected package from current directory: {package}")
+        package = self._resolve_package(args)
         if not package:
             logger.error(
-                "No package specified and could not detect one from the current directory.\n"
-                "Either run from within a package directory (e.g. sdk/core/azure-core) or\n"
-                "pass the package path explicitly:\n\n"
+                "No package specified or discovered for target. Either run from a package\n"
+                "root with '.' or pass the package path/name explicitly:\n\n"
                 "    azpysdk changelog create sdk/core/azure-core\n"
+                "    azpysdk changelog create azure-core\n"
+                "    azpysdk changelog create .    # from the package root\n"
             )
             return 1
         chronus_args.extend(["--package", package])
@@ -349,15 +297,12 @@ def _run_create(self, args: argparse.Namespace) -> int:
     def _run_status(self, args: argparse.Namespace) -> int:
         """Run ``chronus status`` to show pending changes.
 
-        When no *package* argument is given but CWD is inside a package
-        directory, the package path is detected automatically and passed
-        via ``--only`` so only that package's status is shown.
+        When ``args.target`` resolves to a specific package, chronus is
+        scoped to it via ``--only``.  Otherwise status is shown for all
+        packages.
         """
         chronus_args = ["status"]
-        detected_from_cwd = not args.package
-        package = self._resolve_package(args.package)
-        if package and detected_from_cwd:
-            logger.info(f"Detected package from current directory: {package}")
+        package = self._resolve_package(args)
         if package:
             chronus_args.extend(["--only", package])
         return self._run_chronus(chronus_args)