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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: m365-roadmap-mcp
-Version: 0.2.1
+Version: 0.3.0
 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 -->

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.0}/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 -->

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "m365-roadmap-mcp"
-version = "0.2.1"
+version = "0.3.0"
 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.0}/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.0}/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.0}/src/m365_roadmap_mcp/server.py

@@ -22,13 +22,20 @@ 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\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."
     ),
 )
 

m365_roadmap_mcp-0.3.0/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.0/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.0/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.2.1 → m365_roadmap_mcp-0.3.0}/src/m365_roadmap_mcp/tools/search.py

@@ -12,6 +12,11 @@ async def search_roadmap(
     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,
     limit: int = 10,
 ) -> dict:
     """Search the Microsoft 365 Roadmap for features matching keywords and filters.
@@ -29,6 +34,11 @@ async def search_roadmap(
     - 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:
@@ -43,6 +53,14 @@ async def search_roadmap(
         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).
         limit: Maximum number of results to return (default: 10, max: 100).
             Ignored when feature_id is provided.
 
@@ -78,11 +96,21 @@ async def search_roadmap(
         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 = []
@@ -102,6 +130,26 @@ async def search_roadmap(
             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)
+        if rollout_date_lower:
+            if not feature.public_disclosure_date or rollout_date_lower not in feature.public_disclosure_date.lower():
+                continue
+
+        # Preview date filter (partial match against publicPreviewDate)
+        if preview_date_lower:
+            if not feature.public_preview_date or preview_date_lower not in feature.public_preview_date.lower():
+                continue
+
         # Keyword search (title + description)
         if query_lower:
             if (
@@ -123,6 +171,19 @@ async def search_roadmap(
             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
@@ -138,6 +199,17 @@ async def search_roadmap(
     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"
 

{m365_roadmap_mcp-0.2.1 → m365_roadmap_mcp-0.3.0}/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"

m365_roadmap_mcp-0.3.0/tests/test_tools.py

@@ -0,0 +1,589 @@
+"""Tests for MCP tools."""
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# search_roadmap
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_search_no_filters_returns_recent():
+    """When called with no filters, returns the most recent features."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(limit=5)
+
+    assert isinstance(result, dict)
+    assert "total_found" in result
+    assert "features" in result
+    assert "filters_applied" in result
+    assert len(result["features"]) <= 5
+
+
+@pytest.mark.asyncio
+async def test_search_by_keyword():
+    """Keyword filter matches title or description."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(query="Microsoft", limit=5)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        text = (feature["title"] + feature["description"]).lower()
+        assert "microsoft" in text
+    assert result["filters_applied"].get("query") == "Microsoft"
+
+
+@pytest.mark.asyncio
+async def test_search_by_product():
+    """Product filter returns features tagged with the given product."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(product="Teams", limit=5)
+
+    assert isinstance(result["features"], list)
+    assert len(result["features"]) <= 5
+    for feature in result["features"]:
+        assert any("teams" in tag.lower() for tag in feature["tags"])
+    assert result["filters_applied"].get("product") == "Teams"
+
+
+@pytest.mark.asyncio
+async def test_search_by_status():
+    """Status filter returns only matching status."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(status="In development", limit=5)
+
+    for feature in result["features"]:
+        assert feature["status"].lower() == "in development"
+    assert result["filters_applied"].get("status") == "In development"
+
+
+@pytest.mark.asyncio
+async def test_search_by_cloud_instance():
+    """Cloud instance filter returns features available for that instance."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(cloud_instance="GCC", limit=5)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert any("gcc" in ci.lower() for ci in feature["cloud_instances"])
+    assert result["filters_applied"].get("cloud_instance") == "GCC"
+
+
+@pytest.mark.asyncio
+async def test_search_by_feature_id():
+    """Feature ID lookup retrieves a single specific feature."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    # First get a valid ID
+    recent = await search_roadmap(limit=1)
+    if recent["features"]:
+        fid = recent["features"][0]["id"]
+        result = await search_roadmap(feature_id=fid)
+
+        assert result["total_found"] == 1
+        assert result["features"][0]["id"] == fid
+        assert result["filters_applied"].get("feature_id") == fid
+
+
+@pytest.mark.asyncio
+async def test_search_by_feature_id_not_found():
+    """Feature ID lookup for nonexistent ID returns empty results."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(feature_id="nonexistent-id-99999")
+
+    assert result["total_found"] == 0
+    assert result["features"] == []
+
+
+@pytest.mark.asyncio
+async def test_search_combined_filters():
+    """Multiple filters can be combined."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(
+        query="Microsoft",
+        status="In development",
+        limit=5,
+    )
+
+    assert isinstance(result, dict)
+    for feature in result["features"]:
+        text = (feature["title"] + feature["description"]).lower()
+        assert "microsoft" in text
+        assert feature["status"].lower() == "in development"
+
+
+@pytest.mark.asyncio
+async def test_search_limit_clamping():
+    """Limit is clamped between 1 and 100."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result_low = await search_roadmap(limit=0)
+    assert len(result_low["features"]) >= 0  # limit clamped to 1
+    assert len(result_low["features"]) <= 1
+
+    result_high = await search_roadmap(limit=999)
+    assert len(result_high["features"]) <= 100
+
+
+@pytest.mark.asyncio
+async def test_search_output_structure():
+    """Output includes all expected keys and correct types."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(limit=1)
+
+    assert "total_found" in result
+    assert "features" in result
+    assert "filters_applied" in result
+    assert isinstance(result["total_found"], int)
+    assert isinstance(result["features"], list)
+    assert isinstance(result["filters_applied"], dict)
+
+    if result["features"]:
+        feature = result["features"][0]
+        assert "id" in feature
+        assert "title" in feature
+        assert "description" in feature
+        assert "status" in feature
+        assert "tags" in feature
+        assert "cloud_instances" in feature
+        assert "public_disclosure_date" in feature
+
+
+# ---------------------------------------------------------------------------
+# added_within_days
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_basic():
+    """added_within_days returns features and reports the filter."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(added_within_days=30)
+
+    assert isinstance(result, dict)
+    assert isinstance(result["features"], list)
+    assert result["filters_applied"].get("added_within_days") == 30
+    assert "cutoff_date" in result["filters_applied"]
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_larger_window_gte_smaller():
+    """A larger time window should return >= features than a smaller one."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    small = await search_roadmap(added_within_days=7, limit=100)
+    large = await search_roadmap(added_within_days=90, limit=100)
+
+    assert large["total_found"] >= small["total_found"]
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_clamping_low():
+    """Days below 1 is clamped to 1."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(added_within_days=0)
+
+    assert result["filters_applied"]["added_within_days"] == 1
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_clamping_high():
+    """Days above 365 is clamped to 365."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(added_within_days=9999)
+
+    assert result["filters_applied"]["added_within_days"] == 365
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_features_have_created_date():
+    """All returned features should have a created date when filtering by recency."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(added_within_days=365, limit=100)
+
+    for feature in result["features"]:
+        assert feature["created"] is not None
+        assert feature["created"] != ""
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_combined_with_product():
+    """added_within_days can be combined with other filters."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(product="Teams", added_within_days=365, limit=5)
+
+    assert result["filters_applied"].get("product") == "Teams"
+    assert result["filters_applied"].get("added_within_days") == 365
+    for feature in result["features"]:
+        assert any("teams" in tag.lower() for tag in feature["tags"])
+        assert feature["created"] is not None
+
+
+@pytest.mark.asyncio
+async def test_added_within_days_none_means_no_filter():
+    """When added_within_days is None, no recency filter is applied."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(limit=5)
+
+    assert "added_within_days" not in result["filters_applied"]
+    assert "cutoff_date" not in result["filters_applied"]
+
+
+# ---------------------------------------------------------------------------
+# release_phase filter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_search_by_release_phase():
+    """Release phase filter returns features with matching release phase."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(release_phase="General Availability", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert any("general availability" in rp.lower() for rp in feature["release_phases"])
+    assert result["filters_applied"].get("release_phase") == "General Availability"
+
+
+@pytest.mark.asyncio
+async def test_search_by_release_phase_partial_match():
+    """Release phase filter supports partial matching."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(release_phase="preview", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert any("preview" in rp.lower() for rp in feature["release_phases"])
+
+
+@pytest.mark.asyncio
+async def test_search_by_release_phase_case_insensitive():
+    """Release phase filter is case-insensitive."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result_lower = await search_roadmap(release_phase="preview", limit=10)
+    result_upper = await search_roadmap(release_phase="PREVIEW", limit=10)
+
+    assert result_lower["total_found"] == result_upper["total_found"]
+
+
+# ---------------------------------------------------------------------------
+# platform filter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_search_by_platform():
+    """Platform filter returns features with matching platform."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(platform="Web", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert any("web" in p.lower() for p in feature["platforms"])
+    assert result["filters_applied"].get("platform") == "Web"
+
+
+@pytest.mark.asyncio
+async def test_search_by_platform_multiple():
+    """Platform filter can match different platform values."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result_web = await search_roadmap(platform="Web", limit=100)
+    result_ios = await search_roadmap(platform="iOS", limit=100)
+
+    # Both should return some results (assuming data exists)
+    assert result_web["total_found"] >= 0
+    assert result_ios["total_found"] >= 0
+
+
+@pytest.mark.asyncio
+async def test_search_by_platform_combined_with_product():
+    """Platform filter can be combined with product filter."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(platform="Web", product="Teams", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert any("web" in p.lower() for p in feature["platforms"])
+        assert any("teams" in tag.lower() for tag in feature["tags"])
+    assert result["filters_applied"].get("platform") == "Web"
+    assert result["filters_applied"].get("product") == "Teams"
+
+
+# ---------------------------------------------------------------------------
+# rollout_date filter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_search_by_rollout_date_year():
+    """Rollout date filter matches year in publicDisclosureAvailabilityDate."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(rollout_date="2026", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["public_disclosure_date"] is not None
+        assert "2026" in feature["public_disclosure_date"]
+    assert result["filters_applied"].get("rollout_date") == "2026"
+
+
+@pytest.mark.asyncio
+async def test_search_by_rollout_date_month():
+    """Rollout date filter supports partial month matching."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(rollout_date="December 2026", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["public_disclosure_date"] is not None
+        assert "december" in feature["public_disclosure_date"].lower()
+        assert "2026" in feature["public_disclosure_date"]
+
+
+@pytest.mark.asyncio
+async def test_search_by_rollout_date_filters_nulls():
+    """Rollout date filter excludes features with no publicDisclosureAvailabilityDate."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(rollout_date="2026", limit=100)
+
+    for feature in result["features"]:
+        assert feature["public_disclosure_date"] is not None
+        assert feature["public_disclosure_date"] != ""
+
+
+@pytest.mark.asyncio
+async def test_search_by_rollout_date_case_insensitive():
+    """Rollout date filter is case-insensitive."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result_lower = await search_roadmap(rollout_date="december 2026", limit=10)
+    result_upper = await search_roadmap(rollout_date="DECEMBER 2026", limit=10)
+
+    assert result_lower["total_found"] == result_upper["total_found"]
+
+
+# ---------------------------------------------------------------------------
+# preview_date filter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_search_by_preview_date():
+    """Preview date filter matches publicPreviewDate."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(preview_date="2026", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["public_preview_date"] is not None
+        assert "2026" in feature["public_preview_date"]
+    assert result["filters_applied"].get("preview_date") == "2026"
+
+
+@pytest.mark.asyncio
+async def test_search_by_preview_date_partial():
+    """Preview date filter supports partial matching."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(preview_date="July", limit=10)
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["public_preview_date"] is not None
+        assert "july" in feature["public_preview_date"].lower()
+
+
+@pytest.mark.asyncio
+async def test_search_by_preview_date_filters_nulls():
+    """Preview date filter excludes features with no publicPreviewDate."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(preview_date="2026", limit=100)
+
+    for feature in result["features"]:
+        assert feature["public_preview_date"] is not None
+        assert feature["public_preview_date"] != ""
+
+
+# ---------------------------------------------------------------------------
+# modified_within_days filter
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_basic():
+    """modified_within_days returns features and reports the filter."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(modified_within_days=30)
+
+    assert isinstance(result, dict)
+    assert isinstance(result["features"], list)
+    assert result["filters_applied"].get("modified_within_days") == 30
+    assert "modified_cutoff_date" in result["filters_applied"]
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_larger_window_gte_smaller():
+    """A larger time window should return >= features than a smaller one."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    small = await search_roadmap(modified_within_days=7, limit=100)
+    large = await search_roadmap(modified_within_days=90, limit=100)
+
+    assert large["total_found"] >= small["total_found"]
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_clamping_low():
+    """Days below 1 is clamped to 1."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(modified_within_days=0)
+
+    assert result["filters_applied"]["modified_within_days"] == 1
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_clamping_high():
+    """Days above 365 is clamped to 365."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(modified_within_days=9999)
+
+    assert result["filters_applied"]["modified_within_days"] == 365
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_features_have_modified_date():
+    """All returned features should have a modified date when filtering by recency."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(modified_within_days=365, limit=100)
+
+    for feature in result["features"]:
+        assert feature["modified"] is not None
+        assert feature["modified"] != ""
+
+
+@pytest.mark.asyncio
+async def test_modified_within_days_combined_with_other():
+    """modified_within_days can be combined with other filters."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(product="Teams", modified_within_days=365, limit=5)
+
+    assert result["filters_applied"].get("product") == "Teams"
+    assert result["filters_applied"].get("modified_within_days") == 365
+    for feature in result["features"]:
+        assert any("teams" in tag.lower() for tag in feature["tags"])
+        assert feature["modified"] is not None
+
+
+# ---------------------------------------------------------------------------
+# combined new filters
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_combined_new_filters():
+    """All new filters can be combined together."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(
+        release_phase="General Availability",
+        platform="Web",
+        rollout_date="2026",
+        modified_within_days=365,
+        limit=10,
+    )
+
+    assert isinstance(result["features"], list)
+    assert result["filters_applied"].get("release_phase") == "General Availability"
+    assert result["filters_applied"].get("platform") == "Web"
+    assert result["filters_applied"].get("rollout_date") == "2026"
+    assert result["filters_applied"].get("modified_within_days") == 365
+
+
+@pytest.mark.asyncio
+async def test_combined_date_filters():
+    """Date filters can be combined together."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(
+        rollout_date="2026",
+        preview_date="2026",
+        limit=10,
+    )
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["public_disclosure_date"] is not None
+        assert "2026" in feature["public_disclosure_date"]
+        assert feature["public_preview_date"] is not None
+        assert "2026" in feature["public_preview_date"]
+
+
+@pytest.mark.asyncio
+async def test_combined_recency_filters():
+    """Both recency filters can be combined."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    result = await search_roadmap(
+        added_within_days=365,
+        modified_within_days=365,
+        limit=10,
+    )
+
+    assert isinstance(result["features"], list)
+    for feature in result["features"]:
+        assert feature["created"] is not None
+        assert feature["modified"] is not None
+
+
+# ---------------------------------------------------------------------------
+# regression test - original issue
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_december_2026_includes_universal_print():
+    """December 2026 search should include Universal Print feature (original issue)."""
+    from m365_roadmap_mcp.tools.search import search_roadmap
+
+    # API uses format "December CY2026", not "December 2026"
+    result = await search_roadmap(rollout_date="December CY2026", limit=100)
+
+    # Check if Universal Print feature is in the results
+    titles = [f["title"].lower() for f in result["features"]]
+    has_universal_print = any("universal print" in title for title in titles)
+
+    # This should be true if the original issue is fixed
+    assert result["total_found"] > 0, "Should return features for December CY2026"
+    assert has_universal_print, "Universal Print feature should be in December CY2026 results"

m365_roadmap_mcp-0.2.1/tests/test_tools.py

@@ -1,244 +0,0 @@
-"""Tests for MCP tools."""
-
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# search_roadmap
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_search_no_filters_returns_recent():
-    """When called with no filters, returns the most recent features."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(limit=5)
-
-    assert isinstance(result, dict)
-    assert "total_found" in result
-    assert "features" in result
-    assert "filters_applied" in result
-    assert len(result["features"]) <= 5
-
-
-@pytest.mark.asyncio
-async def test_search_by_keyword():
-    """Keyword filter matches title or description."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(query="Microsoft", limit=5)
-
-    assert isinstance(result["features"], list)
-    for feature in result["features"]:
-        text = (feature["title"] + feature["description"]).lower()
-        assert "microsoft" in text
-    assert result["filters_applied"].get("query") == "Microsoft"
-
-
-@pytest.mark.asyncio
-async def test_search_by_product():
-    """Product filter returns features tagged with the given product."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(product="Teams", limit=5)
-
-    assert isinstance(result["features"], list)
-    assert len(result["features"]) <= 5
-    for feature in result["features"]:
-        assert any("teams" in tag.lower() for tag in feature["tags"])
-    assert result["filters_applied"].get("product") == "Teams"
-
-
-@pytest.mark.asyncio
-async def test_search_by_status():
-    """Status filter returns only matching status."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(status="In development", limit=5)
-
-    for feature in result["features"]:
-        assert feature["status"].lower() == "in development"
-    assert result["filters_applied"].get("status") == "In development"
-
-
-@pytest.mark.asyncio
-async def test_search_by_cloud_instance():
-    """Cloud instance filter returns features available for that instance."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(cloud_instance="GCC", limit=5)
-
-    assert isinstance(result["features"], list)
-    for feature in result["features"]:
-        assert any("gcc" in ci.lower() for ci in feature["cloud_instances"])
-    assert result["filters_applied"].get("cloud_instance") == "GCC"
-
-
-@pytest.mark.asyncio
-async def test_search_by_feature_id():
-    """Feature ID lookup retrieves a single specific feature."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    # First get a valid ID
-    recent = await search_roadmap(limit=1)
-    if recent["features"]:
-        fid = recent["features"][0]["id"]
-        result = await search_roadmap(feature_id=fid)
-
-        assert result["total_found"] == 1
-        assert result["features"][0]["id"] == fid
-        assert result["filters_applied"].get("feature_id") == fid
-
-
-@pytest.mark.asyncio
-async def test_search_by_feature_id_not_found():
-    """Feature ID lookup for nonexistent ID returns empty results."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(feature_id="nonexistent-id-99999")
-
-    assert result["total_found"] == 0
-    assert result["features"] == []
-
-
-@pytest.mark.asyncio
-async def test_search_combined_filters():
-    """Multiple filters can be combined."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(
-        query="Microsoft",
-        status="In development",
-        limit=5,
-    )
-
-    assert isinstance(result, dict)
-    for feature in result["features"]:
-        text = (feature["title"] + feature["description"]).lower()
-        assert "microsoft" in text
-        assert feature["status"].lower() == "in development"
-
-
-@pytest.mark.asyncio
-async def test_search_limit_clamping():
-    """Limit is clamped between 1 and 100."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result_low = await search_roadmap(limit=0)
-    assert len(result_low["features"]) >= 0  # limit clamped to 1
-    assert len(result_low["features"]) <= 1
-
-    result_high = await search_roadmap(limit=999)
-    assert len(result_high["features"]) <= 100
-
-
-@pytest.mark.asyncio
-async def test_search_output_structure():
-    """Output includes all expected keys and correct types."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(limit=1)
-
-    assert "total_found" in result
-    assert "features" in result
-    assert "filters_applied" in result
-    assert isinstance(result["total_found"], int)
-    assert isinstance(result["features"], list)
-    assert isinstance(result["filters_applied"], dict)
-
-    if result["features"]:
-        feature = result["features"][0]
-        assert "id" in feature
-        assert "title" in feature
-        assert "description" in feature
-        assert "status" in feature
-        assert "tags" in feature
-        assert "cloud_instances" in feature
-        assert "public_disclosure_date" in feature
-
-
-# ---------------------------------------------------------------------------
-# added_within_days
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_basic():
-    """added_within_days returns features and reports the filter."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(added_within_days=30)
-
-    assert isinstance(result, dict)
-    assert isinstance(result["features"], list)
-    assert result["filters_applied"].get("added_within_days") == 30
-    assert "cutoff_date" in result["filters_applied"]
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_larger_window_gte_smaller():
-    """A larger time window should return >= features than a smaller one."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    small = await search_roadmap(added_within_days=7, limit=100)
-    large = await search_roadmap(added_within_days=90, limit=100)
-
-    assert large["total_found"] >= small["total_found"]
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_clamping_low():
-    """Days below 1 is clamped to 1."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(added_within_days=0)
-
-    assert result["filters_applied"]["added_within_days"] == 1
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_clamping_high():
-    """Days above 365 is clamped to 365."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(added_within_days=9999)
-
-    assert result["filters_applied"]["added_within_days"] == 365
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_features_have_created_date():
-    """All returned features should have a created date when filtering by recency."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(added_within_days=365, limit=100)
-
-    for feature in result["features"]:
-        assert feature["created"] is not None
-        assert feature["created"] != ""
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_combined_with_product():
-    """added_within_days can be combined with other filters."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(product="Teams", added_within_days=365, limit=5)
-
-    assert result["filters_applied"].get("product") == "Teams"
-    assert result["filters_applied"].get("added_within_days") == 365
-    for feature in result["features"]:
-        assert any("teams" in tag.lower() for tag in feature["tags"])
-        assert feature["created"] is not None
-
-
-@pytest.mark.asyncio
-async def test_added_within_days_none_means_no_filter():
-    """When added_within_days is None, no recency filter is applied."""
-    from m365_roadmap_mcp.tools.search import search_roadmap
-
-    result = await search_roadmap(limit=5)
-
-    assert "added_within_days" not in result["filters_applied"]
-    assert "cutoff_date" not in result["filters_applied"]