m365-roadmap-mcp 0.1.0__py3-none-any.whl

m365_roadmap_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""M365 Roadmap MCP Server - Query the Microsoft 365 Roadmap via MCP."""
+
+__version__ = "0.1.0"

m365_roadmap_mcp/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for python -m m365_roadmap_mcp."""
+
+from .server import main
+
+main()

m365_roadmap_mcp/feeds/__init__.py

@@ -0,0 +1 @@
+"""M365 Roadmap API feed handling."""

m365_roadmap_mcp/feeds/m365_api.py

@@ -0,0 +1,70 @@
+"""M365 Roadmap API fetching and parsing."""
+
+import httpx
+
+from ..models.feature import RoadmapFeature
+
+M365_ROADMAP_API_URL = "https://www.microsoft.com/releasecommunications/api/v1/m365"
+
+
+async def fetch_features() -> list[RoadmapFeature]:
+    """Fetch and parse features from the M365 Roadmap API.
+
+    Returns:
+        List of RoadmapFeature objects sorted by created date (newest first).
+    """
+    async with httpx.AsyncClient() as client:
+        response = await client.get(M365_ROADMAP_API_URL, timeout=30.0)
+        response.raise_for_status()
+
+    items = response.json()
+    features = []
+
+    for item in items:
+        feature = _parse_item(item)
+        if feature:
+            features.append(feature)
+
+    # Sort by created date, newest first
+    features.sort(key=lambda f: f.created or "", reverse=True)
+    return features
+
+
+def _parse_item(item: dict) -> RoadmapFeature | None:
+    """Parse a single API item into a RoadmapFeature.
+
+    Args:
+        item: A dictionary from the API JSON array.
+
+    Returns:
+        RoadmapFeature object or None if parsing fails.
+    """
+    try:
+        # Extract product tags from tagsContainer
+        tags_container = item.get("tagsContainer") or {}
+        products = [
+            p["tagName"]
+            for p in tags_container.get("products", [])
+            if "tagName" in p
+        ]
+
+        # Extract cloud instances from tagsContainer
+        cloud_instances = [
+            c["tagName"]
+            for c in tags_container.get("cloudInstances", [])
+            if "tagName" in c
+        ]
+
+        return RoadmapFeature(
+            id=str(item.get("id", "")),
+            title=item.get("title", ""),
+            description=item.get("description", ""),
+            status=item.get("status"),
+            tags=products,
+            cloud_instances=cloud_instances,
+            public_disclosure_date=item.get("publicDisclosureAvailabilityDate"),
+            created=item.get("created"),
+            modified=item.get("modified"),
+        )
+    except Exception:
+        return None

m365_roadmap_mcp/models/__init__.py

@@ -0,0 +1,5 @@
+"""Data models for M365 Roadmap features."""
+
+from .feature import RoadmapFeature
+
+__all__ = ["RoadmapFeature"]

m365_roadmap_mcp/models/feature.py

@@ -0,0 +1,49 @@
+"""Pydantic models for M365 Roadmap features."""
+
+from pydantic import BaseModel, Field
+
+
+class RoadmapFeature(BaseModel):
+    """Represents a single feature from the M365 Roadmap API."""
+
+    id: str = Field(description="Unique Roadmap ID")
+    title: str = Field(description="Feature title")
+    description: str = Field(description="Feature description (HTML/text)")
+    status: str | None = Field(
+        default=None,
+        description="Feature status: In development, Rolling out, or Launched",
+    )
+    tags: list[str] = Field(
+        default_factory=list,
+        description="Product tags (e.g., Microsoft Teams, SharePoint)",
+    )
+    cloud_instances: list[str] = Field(
+        default_factory=list,
+        description="Cloud availability (e.g., Worldwide, GCC, GCC High, DoD)",
+    )
+    public_disclosure_date: str | None = Field(
+        default=None,
+        description="Estimated release date (e.g., August CY2026)",
+    )
+    created: str | None = Field(
+        default=None,
+        description="Date the feature was added to the roadmap",
+    )
+    modified: str | None = Field(
+        default=None,
+        description="Date the feature was last modified",
+    )
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for tool output."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "status": self.status,
+            "tags": self.tags,
+            "cloud_instances": self.cloud_instances,
+            "public_disclosure_date": self.public_disclosure_date,
+            "created": self.created,
+            "modified": self.modified,
+        }

m365_roadmap_mcp/server.py

@@ -0,0 +1,61 @@
+"""M365 Roadmap MCP Server - FastMCP server with stdio/HTTP transport."""
+
+import logging
+import os
+
+from fastmcp import FastMCP
+
+# Suppress FastMCP's INFO logs to reduce console noise
+logging.getLogger("fastmcp").setLevel(logging.WARNING)
+
+from .tools.cloud import check_cloud_availability
+from .tools.details import get_feature_details
+from .tools.recent import list_recent_additions
+from .tools.search import search_roadmap
+
+# Create the MCP server
+mcp = FastMCP(
+    "M365 Roadmap MCP",
+    instructions=(
+        "Query and search the Microsoft 365 Roadmap for upcoming features, "
+        "release dates, and cloud instance availability.\n\n"
+        "Available tools:\n"
+        "- search_roadmap: Find and filter roadmap features by keyword, product, "
+        "status, cloud instance (GCC, GCC High, DoD), or feature ID.\n"
+        "- get_feature_details: Retrieve full metadata for a specific roadmap "
+        "feature by its ID.\n"
+        "- check_cloud_availability: Verify whether a feature is available for a "
+        "specific cloud instance (critical for government/defense clients).\n"
+        "- list_recent_additions: List features recently added to the roadmap "
+        "within a given number of days."
+    ),
+)
+
+# Register tools
+mcp.tool(search_roadmap)
+mcp.tool(get_feature_details)
+mcp.tool(check_cloud_availability)
+mcp.tool(list_recent_additions)
+
+
+def main():
+    """Run the MCP server.
+
+    Uses stdio transport by default (for MCP client auto-start).
+    Set MCP_TRANSPORT=http to run as an HTTP server for remote access.
+    """
+    transport = os.getenv("MCP_TRANSPORT", "stdio")
+
+    if transport == "http":
+        host = os.getenv("MCP_HOST", "0.0.0.0")
+        port = int(os.getenv("MCP_PORT", "8000"))
+        print(f"Starting M365 Roadmap MCP server on {host}:{port}")
+        print(f"MCP endpoint: http://{host}:{port}/mcp")
+        mcp.run(transport="http", host=host, port=port, show_banner=False)
+    else:
+        # stdio transport (default for MCP client auto-start)
+        mcp.run(transport="stdio", show_banner=False)
+
+
+if __name__ == "__main__":
+    main()

m365_roadmap_mcp/tools/__init__.py

@@ -0,0 +1 @@
+"""MCP tools for M365 Roadmap."""

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/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/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/tools/search.py

@@ -0,0 +1,118 @@
+"""Search tool for querying and filtering M365 Roadmap features."""
+
+from ..feeds.m365_api import fetch_features
+
+
+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,
+    limit: int = 10,
+) -> dict:
+    """Search the Microsoft 365 Roadmap for features matching keywords and filters.
+
+    Combines keyword search, product filtering, status filtering, and cloud instance
+    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")
+    - 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.
+        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
+    """
+    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
+    limit = max(1, min(limit, 100))
+
+    # 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
+
+    # 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
+
+        # Keyword search (title + description)
+        if query_lower:
+            if (
+                query_lower not in feature.title.lower()
+                and query_lower not in feature.description.lower()
+            ):
+                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 not filters_applied:
+        filters_applied["note"] = "No filters applied, returning most recent features"
+
+    return {
+        "total_found": len(matched),
+        "features": [f.to_dict() for f in matched[:limit]],
+        "filters_applied": filters_applied,
+    }

m365_roadmap_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: m365-roadmap-mcp
+Version: 0.1.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
+Project-URL: Issues, https://github.com/jonnybottles/M365-roadmap-mcp-server/issues
+Author: Justin Buttler
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agent,gcc,mcp,microsoft-365,roadmap
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: fastmcp
+Requires-Dist: httpx
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# M365-roadmap-mcp-server
+
+A Model Context Protocol (MCP) server that enables AI agents to query the Microsoft 365 Roadmap programmatically.
+
+## Strategic Rationale
+
+For organizations relying on Microsoft 365, Teams, or SharePoint, the "Roadmap" is the single source of truth for upcoming changes. However, navigating the roadmap website manually is cumbersome and disconnected from technical planning workflows. "When is Copilot coming to GCC High?" is a question that affects multi-million dollar contracts and deployment schedules.
+
+Existing research indicates that while RSS feeds exist, there is no tool that allows an AI agent to structurally query this data to answer complex filtering questions. A "Roadmap Scout" MCP server empowers the Agent to act as a release manager, proactively identifying features that enable new capabilities or threaten existing customizations.
+
+## example MCP server
+
+** NOTE THE EXAMPLE MCP SERVER IS THE WAY WE SHOULD MODEL OUR MCP SERVER FOR THIS PROJECT 
+
+## Data Source
+
+This MCP server pulls data from Microsoft's public roadmap API:
+
+- **API Endpoint:** `https://www.microsoft.com/releasecommunications/api/v1/m365`
+- **Authentication:** None required (public endpoint)
+- **RSS Mirror:** `https://www.microsoft.com/microsoft-365/RoadmapFeatureRSS` (same data, RSS format)
+
+This is the same data that powers the [Microsoft 365 Roadmap website](https://www.microsoft.com/en-us/microsoft-365/roadmap). The legacy endpoint (`roadmap-api.azurewebsites.net`) was retired in March 2025.
+
+### Coverage and Limitations
+
+The API returns approximately **1,900 active features** -- those currently In Development, Rolling Out, or recently Launched. This is a hard cap; older or retired features age out of the API and are no longer returned. The roadmap website may display historical features that are no longer present in the API.
+
+There is no official Microsoft documentation for this API. It is a public, unauthenticated endpoint that the community has reverse-engineered. Microsoft Graph does not expose the public M365 roadmap (Graph's Service Communications API covers tenant-specific Message Center posts and Service Health, which is different data).
+
+### Schema
+
+The API returns a JSON array where each item represents a feature:
+
+| Field | Description |
+|-------|-------------|
+| `id` | Unique Roadmap ID (e.g., "93182") |
+| `title` | Feature title |
+| `description` | HTML/Text description |
+| `status` | Enumerated values like "In development", "Rolling out", "Launched" |
+| `tags` | Product associations (e.g., "Microsoft Teams", "SharePoint") |
+| `publicDisclosureAvailabilityDate` | The estimated release target |
+| `cloudInstances` | Critical for government/defense clients. Values include "Worldwide (Standard Multi-Tenant)", "DoD", "GCC" |
+
+## Proposed Tool Definitions
+
+| Tool Name | Description | Arguments (JSON Schema) | Expected Output |
+|-----------|-------------|------------------------|-----------------|
+| `search_roadmap` | Searches the M365 roadmap for features matching keywords and filters | `{ "query": "string", "product": "string", "status": "string" }` | List of feature summaries with IDs and dates |
+| `get_feature_details` | Retrieves the full metadata for a specific roadmap ID | `{ "feature_id": "string" }` | Detailed JSON object including description and instance tags |
+| `check_cloud_availability` | Verifies if a feature is scheduled for a specific cloud instance | `{ "feature_id": "string", "instance": "string (e.g., GCC)" }` | Boolean availability and specific release date for that instance |
+| `list_recent_additions` | Lists features added to the roadmap in the last X days | `{ "days": "integer" }` | List of new features to monitor |
+
+## Example Prompts
+
+Here are 10 prompts you can use with an AI agent connected to this MCP server:
+
+1. **"What Microsoft Teams features are currently rolling out?"**
+   Uses `search_roadmap` with product and status filters to find Teams features in active rollout.
+
+2. **"Is Copilot available for GCC High yet?"**
+   Uses `search_roadmap` to find Copilot features, then `check_cloud_availability` to verify GCC High support for each result.
+
+3. **"Show me everything added to the M365 roadmap in the last 30 days."**
+   Uses `list_recent_additions(days=30)` to surface newly announced features.
+
+4. **"Tell me more about that Microsoft Lists agent feature you just found."**
+   After a prior search, the agent uses `get_feature_details` with the ID from the earlier result to retrieve the full description, cloud instances, and release date.
+
+5. **"Which SharePoint features are in development and available for DoD?"**
+   Uses `search_roadmap` with `product="SharePoint"`, `status="In development"`, and `cloud_instance="DoD"` to combine all three filters.
+
+6. **"Compare GCC and GCC High availability for feature 412718."**
+   Uses `check_cloud_availability` twice -- once with `instance="GCC"` and once with `instance="GCC High"` -- to compare cloud parity for a single feature.
+
+7. **"What new features were added to the roadmap this week?"**
+   Uses `list_recent_additions(days=7)` to get a concise list of the latest additions for a weekly briefing.
+
+8. **"Find all roadmap features related to data loss prevention."**
+   Uses `search_roadmap(query="data loss prevention")` to keyword-search across titles and descriptions.
+
+9. **"My agency is on GCC High. Which OneDrive features can we expect?"**
+   Uses `search_roadmap` with `product="OneDrive"` and `cloud_instance="GCC High"` to find features available for that government cloud.
+
+10. **"List all launched Viva features and check which ones support GCC."**
+    Uses `search_roadmap(product="Viva", status="Launched")` to get candidates, then `check_cloud_availability` on each to filter for GCC support.
+
+## Usage Narrative: Government Compliance Checking
+
+### Scenario
+
+An IT Director for a federal agency (using the GCC High cloud) asks about the availability of a new "Microsoft Lists" feature they saw in a demo.
+
+**User Query:** "My agency is on GCC High. When will we get the new 'Microsoft Lists' agent capabilities?"
+
+### Agent Action
+
+1. **Analysis:** The Agent parses the intent: Product="Microsoft Lists", Feature="agent capabilities", Constraint="GCC High"
+
+2. **Tool Call:** `search_roadmap(query="Lists agent", product="Microsoft Lists")`
+
+3. **Data Retrieval:** The server queries the API. It finds Roadmap ID 534606: "Enables effortless list creation for Copilot users..."
+
+4. **Tool Call:** `check_cloud_availability(feature_id="534606", instance="GCC High")`
+
+5. **Logic:** The server inspects the `cloudInstances` array of the feature object. It looks for "GCC High"
+
+6. **Result:** The array contains "Worldwide (Standard Multi-Tenant)". It does not contain "GCC High"
+
+7. **Synthesis:** The Agent formulates a precise answer
+
+### Response
+
+> "Currently, Roadmap ID 534606 is listed for 'Worldwide (Standard Multi-Tenant)' with a status of 'Rolling Out'. It has not yet been scheduled for the GCC High environment. Based on typical parity delays, this feature is likely 6-12 months away for your tenant."

m365_roadmap_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+m365_roadmap_mcp/__init__.py,sha256=qz6B-DQCFRM2X6JTnpV_csufVZFBugE6D29ieAJUAWw,96
+m365_roadmap_mcp/__main__.py,sha256=D9mYXV4TlB361LHfDDwvxsybz0_7EUsseJ3pZkS9AOo,84
+m365_roadmap_mcp/server.py,sha256=GXKAyCWojGATKInS6vtVW3PKzizSTe2OhHP2kPVR_0g,2107
+m365_roadmap_mcp/feeds/__init__.py,sha256=mVerRhM3n8iwoiupqp4rhqOGOpR2WbtA6MErj5pLG3g,38
+m365_roadmap_mcp/feeds/m365_api.py,sha256=MXvPGxRaE1EIyGYQCF6F94CGarz4qvGoIS6b_yD5t0Y,2058
+m365_roadmap_mcp/models/__init__.py,sha256=Ml_sDvBRyK40Pq4Of0pDExGEBTjyh0QWB4VLu_zKkks,112
+m365_roadmap_mcp/models/feature.py,sha256=NDKZpq4xcWBaujSaI3H7npXTO03Bh4y2BCY5vc4ZUH0,1672
+m365_roadmap_mcp/tools/__init__.py,sha256=nsNOC46HR1ElncjDck0CjOyeCkh1ZugH8YOiaCg_4dE,34
+m365_roadmap_mcp/tools/cloud.py,sha256=NuvztbKyMLc9pKZYD98kih23e09dAKnAeaEXZig2ky0,2562
+m365_roadmap_mcp/tools/details.py,sha256=jgIpi1BhraHPuMT9tQi3d8ikvLF0EZR7p_D7spNlWL0,1067
+m365_roadmap_mcp/tools/recent.py,sha256=Y9I5SS0I2MsV0i98QKtzXrL14AF5yfEyC3f6RiAxj-g,1709
+m365_roadmap_mcp/tools/search.py,sha256=kmFGam_uJsvTvDUcKjoREVSxUBghkDlrS4JevJLePtQ,4550
+m365_roadmap_mcp-0.1.0.dist-info/METADATA,sha256=mHnm1DnW4CEJv1lOVs1CQx77kB82W4fjI6SdsLG_1zc,8120
+m365_roadmap_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+m365_roadmap_mcp-0.1.0.dist-info/entry_points.txt,sha256=GNzyIHa06s1_7BMZzkI4Dsury7aBgUmOYiSXFGNgE6M,66
+m365_roadmap_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=NNt5lEWzqGxqVCVmj-VEeWFxXhtbgCNwFhYcCUffWDI,1071
+m365_roadmap_mcp-0.1.0.dist-info/RECORD,,

m365_roadmap_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

m365_roadmap_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+m365-roadmap-mcp = m365_roadmap_mcp.server:main

m365_roadmap_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Justin Buttler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.