m365-roadmap-mcp 0.2.1__tar.gz → 0.3.1__tar.gz

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: m365-roadmap-mcp
-Version: 0.2.1
+Version: 0.3.1
 Summary: MCP server for querying the Microsoft 365 Roadmap
 Project-URL: Homepage, https://github.com/jonnybottles/M365-roadmap-mcp-server
 Project-URL: Repository, https://github.com/jonnybottles/M365-roadmap-mcp-server
@@ -24,6 +24,8 @@ Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Description-Content-Type: text/markdown
 
+### Disclaimer: This is an independent, self-built project and is not an official Microsoft tool or service.
+
 # M365 Roadmap MCP Server
 
 <!-- mcp-name: io.github.jonnybottles/m365-roadmap -->
@@ -187,6 +189,11 @@ Provides a single **`search_roadmap`** tool that handles all M365 roadmap querie
 - **Cloud instance filter** -- Filter by cloud instance (GCC, GCC High, DoD)
 - **Feature lookup** -- Retrieve full metadata for a specific roadmap ID
 - **Recent additions** -- List features added within the last N days
+- **Release phase filter** -- Filter by release phase (General Availability, Preview, Targeted Release)
+- **Platform filter** -- Filter by platform (Web, Desktop, iOS, Android, Mac)
+- **Rollout date filter** -- Filter by rollout start date (e.g., "December 2026", "2026")
+- **Preview date filter** -- Filter by preview availability date (e.g., "July 2026")
+- **Recently modified** -- List features modified within the last N days
 
 ## Data Source
 

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/README.md

@@ -1,3 +1,5 @@
+### Disclaimer: This is an independent, self-built project and is not an official Microsoft tool or service.
+
 # M365 Roadmap MCP Server
 
 <!-- mcp-name: io.github.jonnybottles/m365-roadmap -->
@@ -161,6 +163,11 @@ Provides a single **`search_roadmap`** tool that handles all M365 roadmap querie
 - **Cloud instance filter** -- Filter by cloud instance (GCC, GCC High, DoD)
 - **Feature lookup** -- Retrieve full metadata for a specific roadmap ID
 - **Recent additions** -- List features added within the last N days
+- **Release phase filter** -- Filter by release phase (General Availability, Preview, Targeted Release)
+- **Platform filter** -- Filter by platform (Web, Desktop, iOS, Android, Mac)
+- **Rollout date filter** -- Filter by rollout start date (e.g., "December 2026", "2026")
+- **Preview date filter** -- Filter by preview availability date (e.g., "July 2026")
+- **Recently modified** -- List features modified within the last N days
 
 ## Data Source
 

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "m365-roadmap-mcp"
-version = "0.2.1"
+version = "0.3.1"
 description = "MCP server for querying the Microsoft 365 Roadmap"
 readme = "README.md"
 license = "MIT"

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/src/m365_roadmap_mcp/feeds/m365_api.py

@@ -55,6 +55,20 @@ def _parse_item(item: dict) -> RoadmapFeature | None:
             if "tagName" in c
         ]
 
+        # Extract release phases from tagsContainer
+        release_phases = [
+            r["tagName"]
+            for r in tags_container.get("releasePhase", [])
+            if "tagName" in r
+        ]
+
+        # Extract platforms from tagsContainer
+        platforms = [
+            p["tagName"]
+            for p in tags_container.get("platforms", [])
+            if "tagName" in p
+        ]
+
         return RoadmapFeature(
             id=str(item.get("id", "")),
             title=item.get("title", ""),
@@ -62,7 +76,10 @@ def _parse_item(item: dict) -> RoadmapFeature | None:
             status=item.get("status"),
             tags=products,
             cloud_instances=cloud_instances,
+            release_phases=release_phases,
+            platforms=platforms,
             public_disclosure_date=item.get("publicDisclosureAvailabilityDate"),
+            public_preview_date=item.get("publicPreviewDate"),
             created=item.get("created"),
             modified=item.get("modified"),
         )

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/src/m365_roadmap_mcp/models/feature.py

@@ -21,9 +21,21 @@ class RoadmapFeature(BaseModel):
         default_factory=list,
         description="Cloud availability (e.g., Worldwide, GCC, GCC High, DoD)",
     )
+    release_phases: list[str] = Field(
+        default_factory=list,
+        description="Release phases (e.g., General Availability, Preview, Targeted Release)",
+    )
+    platforms: list[str] = Field(
+        default_factory=list,
+        description="Target platforms (e.g., Web, Desktop, iOS, Android, Mac)",
+    )
     public_disclosure_date: str | None = Field(
         default=None,
-        description="Estimated release date (e.g., August CY2026)",
+        description="Estimated rollout start date (e.g., December CY2026)",
+    )
+    public_preview_date: str | None = Field(
+        default=None,
+        description="Estimated preview availability date (e.g., July 2026)",
     )
     created: str | None = Field(
         default=None,
@@ -43,7 +55,10 @@ class RoadmapFeature(BaseModel):
             "status": self.status,
             "tags": self.tags,
             "cloud_instances": self.cloud_instances,
+            "release_phases": self.release_phases,
+            "platforms": self.platforms,
             "public_disclosure_date": self.public_disclosure_date,
+            "public_preview_date": self.public_preview_date,
             "created": self.created,
             "modified": self.modified,
         }

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/src/m365_roadmap_mcp/server.py

@@ -22,13 +22,22 @@ mcp = FastMCP(
         "- status: filter by status ('In development', 'Rolling out', 'Launched')\n"
         "- cloud_instance: filter by cloud instance ('GCC', 'GCC High', 'DoD')\n"
         "- feature_id: retrieve a single feature by its roadmap ID\n"
-        "- added_within_days: show only features added within N days\n\n"
+        "- added_within_days: show only features added within N days\n"
+        "- release_phase: filter by release phase ('General Availability', 'Preview')\n"
+        "- platform: filter by platform ('Web', 'Desktop', 'iOS', 'Android', 'Mac')\n"
+        "- rollout_date: filter by rollout start date (e.g. 'December 2026')\n"
+        "- preview_date: filter by preview availability date (e.g. 'July 2026')\n"
+        "- modified_within_days: show only features modified within N days\n"
+        "- include_facets: include taxonomy facets with counts (default: False)\n\n"
         "Tips:\n"
         "- To get feature details, use feature_id with the roadmap ID.\n"
         "- To check cloud availability, use cloud_instance with a feature_id or "
         "product filter. The cloud_instances field in each result shows all "
         "supported instances.\n"
-        "- To list recent additions, use added_within_days (e.g. 30 for last month)."
+        "- To list recent additions, use added_within_days (e.g. 30 for last month).\n"
+        "- To filter by release phase or platform, use release_phase or platform filters.\n"
+        "- To search by dates, use rollout_date or preview_date with partial date strings.\n"
+        "- To discover available filter values, use include_facets=True (optionally with limit=0)."
     ),
 )
 

m365_roadmap_mcp-0.3.1/src/m365_roadmap_mcp/tools/cloud.py

@@ -0,0 +1,70 @@
+"""Tool for checking cloud instance availability of M365 Roadmap features."""
+
+from ..feeds.m365_api import fetch_features
+
+
+async def check_cloud_availability(feature_id: str, instance: str) -> dict:
+    """Check whether a Microsoft 365 Roadmap feature is available for a specific cloud instance.
+
+    Critical for government and defense clients who need to verify feature availability
+    on GCC, GCC High, or DoD cloud instances before planning deployments.
+
+    Args:
+        feature_id: The unique Roadmap ID (e.g., "534606").
+        instance: The cloud instance to check (e.g., "GCC", "GCC High", "DoD",
+            "Worldwide"). Case-insensitive partial match is used, so "gcc" matches
+            "GCC" and "GCC High".
+
+    Returns:
+        Dictionary with:
+        - feature_id: The queried feature ID
+        - instance_queried: The cloud instance that was checked
+        - found: Whether the feature was found in the roadmap
+        - available: Whether the feature is available for the queried instance
+        - matched_instances: List of cloud instances that matched the query
+        - all_instances: All cloud instances the feature supports
+        - status: Feature status (if found)
+        - public_disclosure_date: Estimated release date (if found)
+        - title: Feature title (if found)
+        - error: Error message (if feature not found)
+    """
+    features = await fetch_features()
+
+    # Find the feature by ID
+    target = None
+    for feature in features:
+        if feature.id == feature_id:
+            target = feature
+            break
+
+    if target is None:
+        return {
+            "feature_id": feature_id,
+            "instance_queried": instance,
+            "found": False,
+            "available": False,
+            "matched_instances": [],
+            "all_instances": [],
+            "status": None,
+            "public_disclosure_date": None,
+            "title": None,
+            "error": f"No feature found with ID '{feature_id}'",
+        }
+
+    # Case-insensitive partial match on cloud instances
+    instance_lower = instance.lower()
+    matched = [
+        ci for ci in target.cloud_instances if instance_lower in ci.lower()
+    ]
+
+    return {
+        "feature_id": feature_id,
+        "instance_queried": instance,
+        "found": True,
+        "available": len(matched) > 0,
+        "matched_instances": matched,
+        "all_instances": target.cloud_instances,
+        "status": target.status,
+        "public_disclosure_date": target.public_disclosure_date,
+        "title": target.title,
+    }

m365_roadmap_mcp-0.3.1/src/m365_roadmap_mcp/tools/details.py

@@ -0,0 +1,35 @@
+"""Tool for retrieving full details of a single M365 Roadmap feature."""
+
+from ..feeds.m365_api import fetch_features
+
+
+async def get_feature_details(feature_id: str) -> dict:
+    """Retrieve full metadata for a specific Microsoft 365 Roadmap feature by its ID.
+
+    Use this tool when you need complete details about a known roadmap feature,
+    including its description, status, product tags, cloud instance availability,
+    and release date.
+
+    Args:
+        feature_id: The unique Roadmap ID (e.g., "534606").
+
+    Returns:
+        Dictionary with:
+        - found: Whether the feature was found
+        - feature: Full feature object if found, None otherwise
+        - error: Error message if not found
+    """
+    features = await fetch_features()
+
+    for feature in features:
+        if feature.id == feature_id:
+            return {
+                "found": True,
+                "feature": feature.to_dict(),
+            }
+
+    return {
+        "found": False,
+        "feature": None,
+        "error": f"No feature found with ID '{feature_id}'",
+    }

m365_roadmap_mcp-0.3.1/src/m365_roadmap_mcp/tools/recent.py

@@ -0,0 +1,50 @@
+"""Tool for listing recently added M365 Roadmap features."""
+
+from datetime import datetime, timedelta, timezone
+
+from ..feeds.m365_api import fetch_features
+
+
+async def list_recent_additions(days: int = 7) -> dict:
+    """List features recently added to the Microsoft 365 Roadmap.
+
+    Use this tool to monitor what new features have appeared on the roadmap
+    within a given time window. Useful for staying current on Microsoft's
+    latest plans and announcements.
+
+    Args:
+        days: Number of days to look back (default: 7, clamped to 1–365).
+
+    Returns:
+        Dictionary with:
+        - total_found: Number of features added within the time window
+        - features: List of recently added feature objects
+        - days_queried: The actual number of days used (after clamping)
+        - cutoff_date: The earliest date included in the results (ISO format)
+    """
+    # Clamp days to reasonable bounds
+    days = max(1, min(days, 365))
+
+    cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+    features = await fetch_features()
+
+    recent = []
+    for feature in features:
+        if not feature.created:
+            continue
+        try:
+            created_dt = datetime.fromisoformat(feature.created)
+            # Ensure timezone-aware comparison
+            if created_dt.tzinfo is None:
+                created_dt = created_dt.replace(tzinfo=timezone.utc)
+            if created_dt >= cutoff:
+                recent.append(feature)
+        except (ValueError, TypeError):
+            continue
+
+    return {
+        "total_found": len(recent),
+        "features": [f.to_dict() for f in recent],
+        "days_queried": days,
+        "cutoff_date": cutoff.isoformat(),
+    }

m365_roadmap_mcp-0.3.1/src/m365_roadmap_mcp/tools/search.py

@@ -0,0 +1,293 @@
+"""Search tool for querying and filtering M365 Roadmap features."""
+
+from collections import Counter
+from datetime import datetime, timedelta, timezone
+
+from ..feeds.m365_api import fetch_features
+from ..models.feature import RoadmapFeature
+
+
+def compute_facets(features: list[RoadmapFeature]) -> dict:
+    """Compute facet counts from a list of features.
+
+    Args:
+        features: List of RoadmapFeature objects to analyze
+
+    Returns:
+        Dictionary with facet categories and counts
+    """
+    products = Counter()
+    statuses = Counter()
+    release_phases = Counter()
+    platforms = Counter()
+    cloud_instances = Counter()
+
+    for feature in features:
+        # Products (from tags)
+        for tag in feature.tags:
+            products[tag] += 1
+
+        # Status
+        if feature.status:
+            statuses[feature.status] += 1
+
+        # Release phases
+        for rp in feature.release_phases:
+            release_phases[rp] += 1
+
+        # Platforms
+        for p in feature.platforms:
+            platforms[p] += 1
+
+        # Cloud instances
+        for ci in feature.cloud_instances:
+            cloud_instances[ci] += 1
+
+    return {
+        "products": [{"name": k, "count": v} for k, v in products.most_common()],
+        "statuses": [{"name": k, "count": v} for k, v in statuses.most_common()],
+        "release_phases": [{"name": k, "count": v} for k, v in release_phases.most_common()],
+        "platforms": [{"name": k, "count": v} for k, v in platforms.most_common()],
+        "cloud_instances": [{"name": k, "count": v} for k, v in cloud_instances.most_common()],
+    }
+
+
+async def search_roadmap(
+    query: str | None = None,
+    product: str | None = None,
+    status: str | None = None,
+    cloud_instance: str | None = None,
+    feature_id: str | None = None,
+    added_within_days: int | None = None,
+    release_phase: str | None = None,
+    platform: str | None = None,
+    rollout_date: str | None = None,
+    preview_date: str | None = None,
+    modified_within_days: int | None = None,
+    include_facets: bool = False,
+    limit: int = 10,
+) -> dict:
+    """Search the Microsoft 365 Roadmap for features matching keywords and filters.
+
+    Combines keyword search, product filtering, status filtering, cloud instance
+    filtering, and recency filtering into a single flexible tool. All filter
+    parameters are optional and can be combined. When no filters are provided,
+    returns the most recent features.
+
+    Use this tool to:
+    - Browse recent roadmap features (no filters)
+    - Search for features by keyword (query="Copilot")
+    - Filter by product (product="Microsoft Teams")
+    - Find features by status (status="In development", "Rolling out", "Launched")
+    - Filter by cloud instance (cloud_instance="GCC High", "DoD", "GCC")
+    - Retrieve a specific feature by ID (feature_id="534606")
+    - List recently added features (added_within_days=30)
+    - Filter by release phase (release_phase="General Availability", "Preview")
+    - Filter by platform (platform="Web", "iOS", "Android")
+    - Filter by rollout date (rollout_date="December 2026")
+    - Filter by preview date (preview_date="July 2026")
+    - List recently modified features (modified_within_days=7)
+    - Combine any of the above (query="Copilot" + product="Teams" + cloud_instance="GCC")
+
+    Args:
+        query: Optional keyword to match against title and description (case-insensitive).
+        product: Optional product tag to filter by (case-insensitive partial match,
+            e.g. "Teams" matches "Microsoft Teams").
+        status: Optional status filter. Valid values: In development, Rolling out, Launched.
+        cloud_instance: Optional cloud instance filter (case-insensitive partial match,
+            e.g. "GCC" matches "GCC", "GCC High" matches "GCC High").
+        feature_id: Optional roadmap ID to retrieve a single specific feature.
+            When provided, all other filters are ignored.
+        added_within_days: Optional number of days to look back for recently added
+            features (clamped to 1–365). Only features with a created date within
+            this window are returned.
+        release_phase: Optional release phase filter (case-insensitive partial match).
+        platform: Optional platform filter (case-insensitive partial match).
+        rollout_date: Optional rollout start date filter (partial string match against
+            publicDisclosureAvailabilityDate, e.g. "December 2026").
+        preview_date: Optional preview availability date filter (partial string match
+            against publicPreviewDate, e.g. "July 2026").
+        modified_within_days: Optional number of days to look back for recently modified
+            features (clamped to 1-365).
+        include_facets: When True, includes taxonomy facets (products, statuses,
+            release_phases, platforms, cloud_instances) with occurrence counts in
+            the response. Use with limit=0 to get only facets without features.
+            Facets are computed from matched results after filters are applied.
+        limit: Maximum number of results to return (default: 10, max: 100).
+            Ignored when feature_id is provided.
+
+    Returns:
+        Dictionary with:
+        - total_found: Number of features matching the filters (before applying limit)
+        - features: List of matching feature objects (up to limit)
+        - filters_applied: Summary of which filters were used
+        - facets: (Optional) Dictionary with facet categories and counts when include_facets=True
+    """
+    features = await fetch_features()
+
+    # Feature ID lookup is a fast path that ignores all other filters
+    if feature_id:
+        for feature in features:
+            if feature.id == feature_id:
+                return {
+                    "total_found": 1,
+                    "features": [feature.to_dict()],
+                    "filters_applied": {"feature_id": feature_id},
+                }
+        return {
+            "total_found": 0,
+            "features": [],
+            "filters_applied": {"feature_id": feature_id},
+        }
+
+    # Clamp limit to reasonable bounds (allow 0 when only requesting facets)
+    min_limit = 0 if include_facets else 1
+    limit = max(min_limit, min(limit, 100))
+
+    # Compute recency cutoff if requested
+    cutoff = None
+    if added_within_days is not None:
+        added_within_days = max(1, min(added_within_days, 365))
+        cutoff = datetime.now(timezone.utc) - timedelta(days=added_within_days)
+
+    # Compute modified cutoff if requested
+    modified_cutoff = None
+    if modified_within_days is not None:
+        modified_within_days = max(1, min(modified_within_days, 365))
+        modified_cutoff = datetime.now(timezone.utc) - timedelta(days=modified_within_days)
+
+    # Prepare lowercase values for case-insensitive matching
+    query_lower = query.lower() if query else None
+    product_lower = product.lower() if product else None
+    status_lower = status.lower() if status else None
+    cloud_lower = cloud_instance.lower() if cloud_instance else None
+    release_phase_lower = release_phase.lower() if release_phase else None
+    platform_lower = platform.lower() if platform else None
+    rollout_date_lower = rollout_date.lower() if rollout_date else None
+    preview_date_lower = preview_date.lower() if preview_date else None
+
+    # Apply all filters
+    matched = []
+    for feature in features:
+        # Status filter
+        if status_lower:
+            if not feature.status or feature.status.lower() != status_lower:
+                continue
+
+        # Product filter (partial match)
+        if product_lower:
+            if not any(product_lower in tag.lower() for tag in feature.tags):
+                continue
+
+        # Cloud instance filter (partial match)
+        if cloud_lower:
+            if not any(cloud_lower in ci.lower() for ci in feature.cloud_instances):
+                continue
+
+        # Release phase filter (partial match)
+        if release_phase_lower:
+            if not any(release_phase_lower in rp.lower() for rp in feature.release_phases):
+                continue
+
+        # Platform filter (partial match)
+        if platform_lower:
+            if not any(platform_lower in p.lower() for p in feature.platforms):
+                continue
+
+        # Rollout date filter (partial match against publicDisclosureAvailabilityDate)
+        # API uses "CY" prefix (e.g., "December CY2026") but users typically omit it
+        if rollout_date_lower:
+            if not feature.public_disclosure_date:
+                continue
+            # Normalize by removing "cy" prefix for comparison
+            normalized_date = feature.public_disclosure_date.lower().replace(" cy", " ")
+            normalized_query = rollout_date_lower.replace(" cy", " ")
+            if normalized_query not in normalized_date:
+                continue
+
+        # Preview date filter (partial match against publicPreviewDate)
+        # API uses "CY" prefix (e.g., "July CY2026") but users typically omit it
+        if preview_date_lower:
+            if not feature.public_preview_date:
+                continue
+            # Normalize by removing "cy" prefix for comparison
+            normalized_date = feature.public_preview_date.lower().replace(" cy", " ")
+            normalized_query = preview_date_lower.replace(" cy", " ")
+            if normalized_query not in normalized_date:
+                continue
+
+        # Keyword search (title + description)
+        if query_lower:
+            if (
+                query_lower not in feature.title.lower()
+                and query_lower not in feature.description.lower()
+            ):
+                continue
+
+        # Recency filter (added_within_days)
+        if cutoff is not None:
+            if not feature.created:
+                continue
+            try:
+                created_dt = datetime.fromisoformat(feature.created)
+                if created_dt.tzinfo is None:
+                    created_dt = created_dt.replace(tzinfo=timezone.utc)
+                if created_dt < cutoff:
+                    continue
+            except (ValueError, TypeError):
+                continue
+
+        # Recency filter (modified_within_days)
+        if modified_cutoff is not None:
+            if not feature.modified:
+                continue
+            try:
+                modified_dt = datetime.fromisoformat(feature.modified)
+                if modified_dt.tzinfo is None:
+                    modified_dt = modified_dt.replace(tzinfo=timezone.utc)
+                if modified_dt < modified_cutoff:
+                    continue
+            except (ValueError, TypeError):
+                continue
+
+        matched.append(feature)
+
+    # Build filters summary
+    filters_applied: dict = {}
+    if query:
+        filters_applied["query"] = query
+    if product:
+        filters_applied["product"] = product
+    if status:
+        filters_applied["status"] = status
+    if cloud_instance:
+        filters_applied["cloud_instance"] = cloud_instance
+    if added_within_days is not None:
+        filters_applied["added_within_days"] = added_within_days
+        filters_applied["cutoff_date"] = cutoff.isoformat()
+    if modified_within_days is not None:
+        filters_applied["modified_within_days"] = modified_within_days
+        filters_applied["modified_cutoff_date"] = modified_cutoff.isoformat()
+    if release_phase:
+        filters_applied["release_phase"] = release_phase
+    if platform:
+        filters_applied["platform"] = platform
+    if rollout_date:
+        filters_applied["rollout_date"] = rollout_date
+    if preview_date:
+        filters_applied["preview_date"] = preview_date
+    if not filters_applied:
+        filters_applied["note"] = "No filters applied, returning most recent features"
+
+    # Build response
+    result = {
+        "total_found": len(matched),
+        "features": [f.to_dict() for f in matched[:limit]],
+        "filters_applied": filters_applied,
+    }
+
+    # Add facets if requested (computed from matched results)
+    if include_facets:
+        result["facets"] = compute_facets(matched)
+
+    return result

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.1}/tests/test_feeds.py

@@ -36,3 +36,29 @@ async def test_features_sorted_by_created_date():
             # Both should have created dates; newest first
             if features[i].created and features[i + 1].created:
                 assert features[i].created >= features[i + 1].created
+
+
+@pytest.mark.asyncio
+async def test_feature_has_new_fields():
+    """Test that features have the newly added fields."""
+    features = await fetch_features()
+
+    if features:
+        feature = features[0]
+        assert hasattr(feature, "release_phases")
+        assert hasattr(feature, "platforms")
+        assert hasattr(feature, "public_preview_date")
+        assert isinstance(feature.release_phases, list)
+        assert isinstance(feature.platforms, list)
+
+
+@pytest.mark.asyncio
+async def test_feature_with_populated_fields():
+    """Test that at least some features have populated release_phases and platforms."""
+    features = await fetch_features()
+
+    has_release_phase = any(len(f.release_phases) > 0 for f in features)
+    has_platform = any(len(f.platforms) > 0 for f in features)
+
+    assert has_release_phase, "No features have release_phases populated"
+    assert has_platform, "No features have platforms populated"