ecosyste-ms-cli 1.3.2__py3-none-any.whl

ecosystems_cli/commands/handlers/commits.py

@@ -0,0 +1,76 @@
+"""Handler for commits API operations."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from .base import OperationHandler
+
+
+class CommitsOperationHandler(OperationHandler):
+    """Handler for commits API operations."""
+
+    # Operation parameter configuration
+    # Maps operation_id -> list of (api_param_name, lowercase_variants)
+    OPERATION_PARAMS = {
+        "getHost": [("hostName", ["hostname"])],
+        "getHostRepositories": [("hostName", ["hostname"])],
+        "getHostRepository": [("hostName", ["hostname"]), ("repoName", ["reponame"])],
+        "getRepositoryCommits": [("hostName", ["hostname"]), ("repoName", ["reponame"])],
+        "getHostCommitter": [("hostName", ["hostname"]), ("login", ["login"])],
+    }
+
+    def _extract_param(self, kwargs: dict, api_name: str, lowercase_variants: List[str]) -> Optional[str]:
+        """Extract parameter from kwargs, trying API name first, then lowercase variants.
+
+        Args:
+            kwargs: Keyword arguments dict
+            api_name: The API parameter name (exact case)
+            lowercase_variants: List of lowercase parameter name variants to try
+
+        Returns:
+            Parameter value if found, None otherwise
+        """
+        # Try exact API name first
+        if api_name in kwargs:
+            return kwargs.pop(api_name)
+
+        # Try lowercase variants
+        for variant in lowercase_variants:
+            if variant in kwargs:
+                return kwargs.pop(variant)
+
+        return None
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for commits API operations.
+
+        Args:
+            operation_id: The operation identifier
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Tuple of (path_params, query_params)
+        """
+        path_params = {}
+        query_params = {}
+
+        # Get parameter configuration for this operation
+        param_config = self.OPERATION_PARAMS.get(operation_id, [])
+
+        # Extract path parameters from args or kwargs
+        for i, (api_name, lowercase_variants) in enumerate(param_config):
+            if i < len(args):
+                # Use positional argument
+                path_params[api_name] = args[i]
+            else:
+                # Try to extract from kwargs
+                value = self._extract_param(kwargs, api_name, lowercase_variants)
+                if value is not None:
+                    path_params[api_name] = value
+
+        # For all operations, remaining kwargs are query parameters
+        for key, value in kwargs.items():
+            if value is not None:
+                query_params[key] = value
+
+        return path_params, query_params

ecosystems_cli/commands/handlers/default.py

@@ -0,0 +1,40 @@
+"""Default handler for standard API operations."""
+
+from typing import Any, Dict, Tuple
+
+from .base import OperationHandler
+
+
+class DefaultOperationHandler(OperationHandler):
+    """Default handler for standard API operations."""
+
+    # Configuration mapping: operation_id -> (param_type, param_name, arg_count)
+    OPERATION_CONFIG = {
+        "getProject": ("path", "id", 1),
+        "getList": ("path", "id", 1),
+        "getListProjects": ("path", "id", 1),
+        "getCollection": ("path", "id", 1),
+        "getCollectionProjects": ("path", "id", 1),
+        "getTopic": ("path", "slug", 1),
+        "getCollective": ("path", "id", 1),
+        "getCollectiveProjects": ("path", "slug", 1),
+        "lookupProject": ("query", "url", 1),
+        "createJob": ("query", "url", 1),
+        "getJob": ("path", "jobID", 1),
+    }
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for standard API operations."""
+        all_args = list(args) + list(kwargs.values())
+
+        config = self.OPERATION_CONFIG.get(operation_id)
+        if config and len(all_args) >= config[2]:
+            param_type, param_name, _ = config
+            value = all_args[0]
+
+            if param_type == "path":
+                return {param_name: value}, {}
+            elif param_type == "query":
+                return {}, {param_name: value}
+
+        return {}, {}

ecosystems_cli/commands/handlers/dependabot.py

@@ -0,0 +1,205 @@
+"""Handler for dependabot API operations."""
+
+from typing import Any, Dict, Tuple
+
+from .base import OperationHandler
+
+
+class DependabotOperationHandler(OperationHandler):
+    """Handler for dependabot API operations.
+
+    Handles parameter mapping for dependabot API operations including:
+    - Package operations: getPackages, getPackage, getEcosystemPackages
+    - Repository operations: getHost, getHostRepository, getHostRepositoryIssues
+    - Advisory operations: getAdvisories, getAdvisory
+    - Lookup operations: repositoriesLookup
+
+    Supports hierarchical path parameters like /hosts/{hostName}/repositories/{repoName}/issues/{issueNumber}
+    """
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for dependabot API operations.
+
+        Args:
+            operation_id: The operation identifier
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Tuple of (path_params, query_params)
+        """
+        handlers = {
+            "getPackages": self._handle_query_params,
+            "getPackageEcosystems": self._handle_no_params,
+            "getEcosystemPackages": self._handle_ecosystem_packages,
+            "getPackage": self._handle_get_package,
+            "getIssuePackages": self._handle_issue_packages,
+            "repositoriesLookup": self._handle_repositories_lookup,
+            "getRegistries": self._handle_query_params,
+            "getHost": self._handle_get_host,
+            "getHostRepositories": self._handle_host_repositories,
+            "getHostRepository": self._handle_host_repository,
+            "getHostRepositoryIssues": self._handle_host_repository_issues,
+            "getHostRepositoryIssue": self._handle_host_repository_issue,
+            "getAdvisories": self._handle_query_params,
+            "getAdvisory": self._handle_get_advisory,
+        }
+
+        handler = handlers.get(operation_id, self._handle_default)
+        return handler(args, kwargs)
+
+    def _handle_ecosystem_packages(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getEcosystemPackages operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        ecosystem = args[0] if args else kwargs.pop("ecosystem", None)
+        if ecosystem:
+            path_params["ecosystem"] = ecosystem
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_get_package(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getPackage operation parameters."""
+        path_params = {}
+
+        if len(args) >= 2:
+            path_params["ecosystem"] = args[0]
+            path_params["name"] = args[1]
+        else:
+            if "ecosystem" in kwargs:
+                path_params["ecosystem"] = kwargs["ecosystem"]
+            if "name" in kwargs:
+                path_params["name"] = kwargs["name"]
+
+        return path_params, {}
+
+    def _handle_issue_packages(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getIssuePackages operation parameters."""
+        path_params = {}
+
+        issue_id = args[0] if args else kwargs.get("issueId")
+        if issue_id:
+            path_params["issueId"] = issue_id
+
+        return path_params, {}
+
+    def _handle_repositories_lookup(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle repositoriesLookup operation parameters."""
+        query_params = {}
+
+        url = args[0] if args else kwargs.get("url")
+        if url:
+            query_params["url"] = url
+
+        return {}, query_params
+
+    def _handle_get_host(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getHost operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        host_name = args[0] if args else kwargs.pop("hostName", None)
+        if host_name:
+            path_params["hostName"] = host_name
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_host_repositories(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getHostRepositories operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        host_name = args[0] if args else kwargs.pop("hostName", None)
+        if host_name:
+            path_params["hostName"] = host_name
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_host_repository(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getHostRepository operation parameters."""
+        path_params = {}
+
+        if len(args) >= 2:
+            path_params["hostName"] = args[0]
+            path_params["repoName"] = args[1]
+        else:
+            if "hostName" in kwargs:
+                path_params["hostName"] = kwargs["hostName"]
+            if "repoName" in kwargs:
+                path_params["repoName"] = kwargs["repoName"]
+
+        return path_params, {}
+
+    def _handle_host_repository_issues(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getHostRepositoryIssues operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        if len(args) >= 2:
+            path_params["hostName"] = args[0]
+            path_params["repoName"] = args[1]
+        else:
+            if "hostName" in kwargs:
+                path_params["hostName"] = kwargs.pop("hostName")
+            if "repoName" in kwargs:
+                path_params["repoName"] = kwargs.pop("repoName")
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_host_repository_issue(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getHostRepositoryIssue operation parameters."""
+        path_params = {}
+
+        if len(args) >= 3:
+            path_params["hostName"] = args[0]
+            path_params["repoName"] = args[1]
+            path_params["issueNumber"] = args[2]
+        else:
+            if "hostName" in kwargs:
+                path_params["hostName"] = kwargs["hostName"]
+            if "repoName" in kwargs:
+                path_params["repoName"] = kwargs["repoName"]
+            if "issueNumber" in kwargs:
+                path_params["issueNumber"] = kwargs["issueNumber"]
+
+        return path_params, {}
+
+    def _handle_get_advisory(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getAdvisory operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        advisory_id = args[0] if args else kwargs.pop("advisoryId", None)
+        if advisory_id:
+            path_params["advisoryId"] = advisory_id
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_query_params(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle operations that only have query parameters."""
+        query_params = {k: v for k, v in kwargs.items() if v is not None}
+        return {}, query_params
+
+    def _handle_no_params(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle operations with no parameters."""
+        return {}, {}
+
+    def _handle_default(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Default handler for unknown operations."""
+        return {}, {}

ecosystems_cli/commands/handlers/diff.py

@@ -0,0 +1,72 @@
+"""Handler for diff API operations."""
+
+from typing import Any, Dict, Tuple
+
+from .base import OperationHandler
+
+
+class DiffOperationHandler(OperationHandler):
+    """Handler for diff API operations.
+
+    Handles parameter mapping for diff API operations including:
+    - createJob: Submit diff job with two URLs to compare
+    - getJob: Get job status and results by job ID
+    """
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for diff API operations.
+
+        Args:
+            operation_id: The operation identifier
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Tuple of (path_params, query_params)
+        """
+        handlers = {
+            "createJob": self._handle_create_job,
+            "getJob": self._handle_get_job,
+        }
+
+        handler = handlers.get(operation_id, self._handle_default)
+        return handler(args, kwargs)
+
+    def _handle_create_job(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle createJob operation parameters.
+
+        Requires two URLs to compare. Can be provided as:
+        - Positional arguments: diff create-job url1 url2
+        - Named arguments: diff create-job --url-1 url1 --url-2 url2
+        """
+        query_params = {}
+
+        if len(args) >= 2:
+            query_params["url_1"] = args[0]
+            query_params["url_2"] = args[1]
+        else:
+            # Try to get from kwargs
+            url_1 = kwargs.get("url_1")
+            url_2 = kwargs.get("url_2")
+
+            if url_1:
+                query_params["url_1"] = url_1
+            if url_2:
+                query_params["url_2"] = url_2
+
+        # Note: API validation will handle missing required parameters
+        return {}, query_params
+
+    def _handle_get_job(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getJob operation parameters."""
+        path_params = {}
+
+        job_id = args[0] if args else kwargs.get("job_id")
+        if job_id:
+            path_params["jobID"] = job_id
+
+        return path_params, {}
+
+    def _handle_default(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Default handler for unknown operations."""
+        return {}, {}

ecosystems_cli/commands/handlers/docker.py

@@ -0,0 +1,142 @@
+"""Handler for docker API operations."""
+
+from typing import Any, Dict, Tuple
+
+from .base import OperationHandler
+
+
+class DockerOperationHandler(OperationHandler):
+    """Handler for docker API operations."""
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for docker API operations.
+
+        Args:
+            operation_id: The operation identifier
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Tuple of (path_params, query_params)
+        """
+        handlers = {
+            "getPackages": self._handle_query_params,
+            "getPackage": self._handle_get_package,
+            "getPackageVersions": self._handle_get_package_versions,
+            "getPackageVersion": self._handle_get_package_version,
+            "usage": self._handle_no_params,
+            "usageEcosystem": self._handle_usage_ecosystem,
+            "usagePackage": self._handle_usage_package,
+            "getDistros": self._handle_query_params,
+            "getDistro": self._handle_get_distro,
+            "getDistroVersions": self._handle_get_distro_versions,
+        }
+
+        handler = handlers.get(operation_id, self._handle_default)
+        return handler(args, kwargs)
+
+    def _handle_get_package(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getPackage operation parameters."""
+        path_params = {}
+
+        # Click normalizes parameter names to lowercase, so check both
+        package_name = args[0] if args else (kwargs.get("packageName") or kwargs.get("packagename"))
+        if package_name:
+            path_params["packageName"] = package_name
+
+        return path_params, {}
+
+    def _handle_get_package_versions(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getPackageVersions operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        # Click normalizes parameter names to lowercase
+        package_name = args[0] if args else (kwargs.pop("packageName", None) or kwargs.pop("packagename", None))
+        if package_name:
+            path_params["packageName"] = package_name
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_get_package_version(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getPackageVersion operation parameters."""
+        path_params = {}
+
+        if len(args) >= 2:
+            path_params["packageName"] = args[0]
+            path_params["versionNumber"] = args[1]
+        else:
+            # Click normalizes parameter names to lowercase
+            if "packageName" in kwargs or "packagename" in kwargs:
+                path_params["packageName"] = kwargs.get("packageName") or kwargs.get("packagename")
+            if "versionNumber" in kwargs or "versionnumber" in kwargs:
+                path_params["versionNumber"] = kwargs.get("versionNumber") or kwargs.get("versionnumber")
+
+        return path_params, {}
+
+    def _handle_usage_ecosystem(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle usageEcosystem operation parameters."""
+        path_params = {}
+
+        ecosystem = args[0] if args else kwargs.get("ecosystem")
+        if ecosystem:
+            path_params["ecosystem"] = ecosystem
+
+        return path_params, {}
+
+    def _handle_usage_package(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle usagePackage operation parameters."""
+        path_params = {}
+
+        if len(args) >= 2:
+            path_params["ecosystem"] = args[0]
+            path_params["package"] = args[1]
+        else:
+            if "ecosystem" in kwargs:
+                path_params["ecosystem"] = kwargs["ecosystem"]
+            if "package" in kwargs:
+                path_params["package"] = kwargs["package"]
+
+        return path_params, {}
+
+    def _handle_get_distro(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getDistro operation parameters."""
+        path_params = {}
+
+        # Click normalizes parameter names to lowercase, so check both
+        slug = args[0] if args else (kwargs.get("slug"))
+        if slug:
+            path_params["slug"] = slug
+
+        return path_params, {}
+
+    def _handle_get_distro_versions(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle getDistroVersions operation parameters."""
+        path_params = {}
+        query_params = {}
+
+        # Click normalizes parameter names to lowercase
+        slug = args[0] if args else kwargs.pop("slug", None)
+        if slug:
+            path_params["slug"] = slug
+
+        # Add remaining kwargs as query parameters
+        query_params.update({k: v for k, v in kwargs.items() if v is not None})
+
+        return path_params, query_params
+
+    def _handle_query_params(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle operations that only have query parameters."""
+        query_params = {k: v for k, v in kwargs.items() if v is not None}
+        return {}, query_params
+
+    def _handle_no_params(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Handle operations with no parameters."""
+        return {}, {}
+
+    def _handle_default(self, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Default handler for unknown operations."""
+        return {}, {}

ecosystems_cli/commands/handlers/factory.py

@@ -0,0 +1,60 @@
+"""Factory for creating operation handlers."""
+
+from typing import Dict, Type
+
+from .advisories import AdvisoriesOperationHandler
+from .archives import ArchivesOperationHandler
+from .base import OperationHandler
+from .commits import CommitsOperationHandler
+from .default import DefaultOperationHandler
+from .dependabot import DependabotOperationHandler
+from .diff import DiffOperationHandler
+from .docker import DockerOperationHandler
+from .issues import IssuesOperationHandler
+from .licenses import LicensesOperationHandler
+from .opencollective import OpenCollectiveOperationHandler
+from .packages import PackagesOperationHandler
+from .parser import ParserOperationHandler
+from .repos import ReposOperationHandler
+from .resolve import ResolveOperationHandler
+from .sbom import SbomOperationHandler
+from .sponsors import SponsorsOperationHandler
+from .summary import SummaryOperationHandler
+from .timeline import TimelineOperationHandler
+
+
+class OperationHandlerFactory:
+    """Factory for creating operation handlers."""
+
+    _handlers: Dict[str, Type[OperationHandler]] = {
+        "advisories": AdvisoriesOperationHandler,
+        "archives": ArchivesOperationHandler,
+        "commits": CommitsOperationHandler,
+        "dependabot": DependabotOperationHandler,
+        "diff": DiffOperationHandler,
+        "docker": DockerOperationHandler,
+        "issues": IssuesOperationHandler,
+        "licenses": LicensesOperationHandler,
+        "opencollective": OpenCollectiveOperationHandler,
+        "packages": PackagesOperationHandler,
+        "parser": ParserOperationHandler,
+        "repos": ReposOperationHandler,
+        "resolve": ResolveOperationHandler,
+        "sbom": SbomOperationHandler,
+        "sponsors": SponsorsOperationHandler,
+        "summary": SummaryOperationHandler,
+        "timeline": TimelineOperationHandler,
+    }
+
+    @classmethod
+    def get_handler(cls, api_name: str) -> OperationHandler:
+        """Get the appropriate handler for an API.
+
+        Args:
+            api_name: Name of the API
+
+        Returns:
+            OperationHandler instance for the API
+        """
+        handler_class = cls._handlers.get(api_name, DefaultOperationHandler)
+        return handler_class()

ecosystems_cli/commands/handlers/issues.py

@@ -0,0 +1,87 @@
+"""Handler for issues API operations."""
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from .base import OperationHandler
+
+
+class IssuesOperationHandler(OperationHandler):
+    """Handler for issues API operations."""
+
+    # Operation parameter configuration
+    # Maps operation_id -> list of (api_param_name, lowercase_variants)
+    OPERATION_PARAMS = {
+        "getHost": [("hostName", ["hostname"])],
+        "getHostRepositories": [("hostName", ["hostname"])],
+        "getHostRepository": [("hostName", ["hostname"]), ("repoName", ["reponame"])],
+        "getHostRepositoryIssues": [("hostName", ["hostname"]), ("repoName", ["reponame"])],
+        "getHostRepositoryIssue": [
+            ("hostName", ["hostname"]),
+            ("repoName", ["reponame"]),
+            ("issueNumber", ["issuenumber", "issue_number"]),
+        ],
+        "getHostRepositoryLabels": [("hostName", ["hostname"]), ("repoName", ["reponame"])],
+        "getHostOwners": [("hostName", ["hostname"])],
+        "getHostOwner": [("hostName", ["hostname"]), ("ownerName", ["ownername"])],
+        "getHostOwnerMaintainers": [("hostName", ["hostname"]), ("ownerName", ["ownername"])],
+        "getHostAuthors": [("hostName", ["hostname"])],
+        "getHostAuthor": [("hostName", ["hostname"]), ("authorName", ["authorname"])],
+        "getJob": [("jobId", ["jobid"])],
+    }
+
+    def _extract_param(self, kwargs: dict, api_name: str, lowercase_variants: List[str]) -> Optional[str]:
+        """Extract parameter from kwargs, trying API name first, then lowercase variants.
+
+        Args:
+            kwargs: Keyword arguments dict
+            api_name: The API parameter name (exact case)
+            lowercase_variants: List of lowercase parameter name variants to try
+
+        Returns:
+            Parameter value if found, None otherwise
+        """
+        # Try exact API name first
+        if api_name in kwargs:
+            return kwargs.pop(api_name)
+
+        # Try lowercase variants
+        for variant in lowercase_variants:
+            if variant in kwargs:
+                return kwargs.pop(variant)
+
+        return None
+
+    def build_params(self, operation_id: str, args: tuple, kwargs: dict) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """Build parameters for issues API operations.
+
+        Args:
+            operation_id: The operation identifier
+            args: Positional arguments
+            kwargs: Keyword arguments
+
+        Returns:
+            Tuple of (path_params, query_params)
+        """
+        path_params = {}
+        query_params = {}
+
+        # Get parameter configuration for this operation
+        param_config = self.OPERATION_PARAMS.get(operation_id, [])
+
+        # Extract path parameters from args or kwargs
+        for i, (api_name, lowercase_variants) in enumerate(param_config):
+            if i < len(args):
+                # Use positional argument
+                path_params[api_name] = args[i]
+            else:
+                # Try to extract from kwargs
+                value = self._extract_param(kwargs, api_name, lowercase_variants)
+                if value is not None:
+                    path_params[api_name] = value
+
+        # For all operations, remaining kwargs are query parameters
+        for key, value in kwargs.items():
+            if value is not None:
+                query_params[key] = value
+
+        return path_params, query_params