feat: implement XER MCP Server with 9 schedule query tools

Implement complete MCP server for parsing Primavera P6 XER files and
exposing schedule data through MCP tools. All 4 user stories complete.

Tools implemented:
- load_xer: Parse XER files into SQLite database
- list_activities: Query activities with pagination and filtering
- get_activity: Get activity details by ID
- list_relationships: Query activity dependencies
- get_predecessors/get_successors: Query activity relationships
- get_project_summary: Project overview with counts
- list_milestones: Query milestone activities
- get_critical_path: Query driving path activities

Features:
- Tab-delimited XER format parsing with pluggable table handlers
- In-memory SQLite database for fast queries
- Pagination with 100-item default limit
- Multi-project file support with project selection
- ISO8601 date formatting
- NO_FILE_LOADED error handling for all query tools

Test coverage: 81 tests (contract, integration, unit)

.gitignore

@@ -0,0 +1,46 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# XER files (may contain sensitive project data)
+*.xer
+
+# OS
+.DS_Store
+Thumbs.db

.python-version

@@ -0,0 +1 @@
+3.14

pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "xer-mcp"
+version = "0.1.0"
+description = "MCP server for querying Primavera P6 XER schedule data"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "mcp>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "ruff>=0.8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/xer_mcp"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py314"
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # Pyflakes
+    "I",      # isort
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "UP",     # pyupgrade
+]
+ignore = [
+    "E501",   # line too long (handled by formatter)
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["src"]

src/xer_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""XER MCP Server - MCP tools for querying Primavera P6 XER schedule data."""
+
+__version__ = "0.1.0"

src/xer_mcp/__main__.py

@@ -0,0 +1,14 @@
+"""Main entry point for the XER MCP Server."""
+
+import asyncio
+
+from xer_mcp.server import run_server
+
+
+def main() -> None:
+    """Run the XER MCP Server."""
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

src/xer_mcp/db/__init__.py

@@ -0,0 +1,66 @@
+"""Database connection management for XER MCP Server."""
+
+import sqlite3
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from xer_mcp.db.schema import get_schema
+
+
+class DatabaseManager:
+    """Manages SQLite database connections and schema initialization."""
+
+    def __init__(self) -> None:
+        """Initialize database manager with in-memory database."""
+        self._connection: sqlite3.Connection | None = None
+
+    def initialize(self) -> None:
+        """Initialize the in-memory database with schema."""
+        self._connection = sqlite3.connect(":memory:", check_same_thread=False)
+        self._connection.row_factory = sqlite3.Row
+        self._connection.executescript(get_schema())
+
+    def clear(self) -> None:
+        """Clear all data from the database."""
+        if self._connection is None:
+            return
+
+        tables = ["relationships", "activities", "wbs", "calendars", "projects"]
+        for table in tables:
+            self._connection.execute(f"DELETE FROM {table}")  # noqa: S608
+        self._connection.commit()
+
+    @property
+    def connection(self) -> sqlite3.Connection:
+        """Get the database connection."""
+        if self._connection is None:
+            raise RuntimeError("Database not initialized. Call initialize() first.")
+        return self._connection
+
+    @contextmanager
+    def cursor(self) -> Generator[sqlite3.Cursor]:
+        """Get a cursor for executing queries."""
+        cur = self.connection.cursor()
+        try:
+            yield cur
+        finally:
+            cur.close()
+
+    def commit(self) -> None:
+        """Commit the current transaction."""
+        self.connection.commit()
+
+    def close(self) -> None:
+        """Close the database connection."""
+        if self._connection is not None:
+            self._connection.close()
+            self._connection = None
+
+    @property
+    def is_initialized(self) -> bool:
+        """Check if the database is initialized."""
+        return self._connection is not None
+
+
+# Global database manager instance
+db = DatabaseManager()

src/xer_mcp/db/loader.py

@@ -0,0 +1,140 @@
+"""Database loader for parsed XER data."""
+
+from xer_mcp.db import db
+from xer_mcp.parser.xer_parser import ParsedXer
+
+
+def load_parsed_data(parsed: ParsedXer, project_id: str) -> None:
+    """Load parsed XER data into the database.
+
+    Only loads data for the specified project.
+
+    Args:
+        parsed: Parsed XER data
+        project_id: ID of the project to load
+    """
+    # Find the project
+    project = next((p for p in parsed.projects if p["proj_id"] == project_id), None)
+    if project is None:
+        raise ValueError(f"Project {project_id} not found in parsed data")
+
+    # Clear existing data
+    db.clear()
+
+    with db.cursor() as cur:
+        # Insert project
+        cur.execute(
+            """
+            INSERT INTO projects (proj_id, proj_short_name, plan_start_date, plan_end_date)
+            VALUES (?, ?, ?, ?)
+            """,
+            (
+                project["proj_id"],
+                project["proj_short_name"],
+                project["plan_start_date"],
+                project["plan_end_date"],
+            ),
+        )
+
+        # Insert WBS elements for this project
+        for wbs in parsed.projwbs:
+            if wbs["proj_id"] == project_id:
+                cur.execute(
+                    """
+                    INSERT INTO wbs (wbs_id, proj_id, parent_wbs_id, wbs_short_name, wbs_name)
+                    VALUES (?, ?, ?, ?, ?)
+                    """,
+                    (
+                        wbs["wbs_id"],
+                        wbs["proj_id"],
+                        wbs["parent_wbs_id"] or None,
+                        wbs["wbs_short_name"],
+                        wbs["wbs_name"],
+                    ),
+                )
+
+        # Insert calendars (all calendars, they may be shared)
+        for cal in parsed.calendars:
+            cur.execute(
+                """
+                INSERT OR IGNORE INTO calendars (clndr_id, clndr_name, day_hr_cnt, week_hr_cnt)
+                VALUES (?, ?, ?, ?)
+                """,
+                (
+                    cal["clndr_id"],
+                    cal["clndr_name"],
+                    cal["day_hr_cnt"],
+                    cal["week_hr_cnt"],
+                ),
+            )
+
+        # Insert activities for this project
+        for task in parsed.tasks:
+            if task["proj_id"] == project_id:
+                cur.execute(
+                    """
+                    INSERT INTO activities (
+                        task_id, proj_id, wbs_id, task_code, task_name, task_type,
+                        target_start_date, target_end_date, act_start_date, act_end_date,
+                        total_float_hr_cnt, driving_path_flag, status_code
+                    )
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        task["task_id"],
+                        task["proj_id"],
+                        task["wbs_id"],
+                        task["task_code"],
+                        task["task_name"],
+                        task["task_type"],
+                        task["target_start_date"],
+                        task["target_end_date"],
+                        task["act_start_date"],
+                        task["act_end_date"],
+                        task["total_float_hr_cnt"],
+                        1 if task["driving_path_flag"] else 0,
+                        task["status_code"],
+                    ),
+                )
+
+        # Build set of task IDs in this project
+        project_task_ids = {t["task_id"] for t in parsed.tasks if t["proj_id"] == project_id}
+
+        # Insert relationships where both tasks are in this project
+        for rel in parsed.taskpreds:
+            if (
+                rel.get("proj_id") == project_id
+                and rel["task_id"] in project_task_ids
+                and rel["pred_task_id"] in project_task_ids
+            ):
+                cur.execute(
+                    """
+                    INSERT INTO relationships (
+                        task_pred_id, task_id, pred_task_id, pred_type, lag_hr_cnt
+                    )
+                    VALUES (?, ?, ?, ?, ?)
+                    """,
+                    (
+                        rel["task_pred_id"],
+                        rel["task_id"],
+                        rel["pred_task_id"],
+                        rel["pred_type"],
+                        rel["lag_hr_cnt"],
+                    ),
+                )
+
+    db.commit()
+
+
+def get_activity_count() -> int:
+    """Get the count of activities in the database."""
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM activities")
+        return cur.fetchone()[0]
+
+
+def get_relationship_count() -> int:
+    """Get the count of relationships in the database."""
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM relationships")
+        return cur.fetchone()[0]

src/xer_mcp/db/queries.py

@@ -0,0 +1,392 @@
+"""Database query functions for XER data."""
+
+from xer_mcp.db import db
+
+
+def query_activities(
+    limit: int = 100,
+    offset: int = 0,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    wbs_id: str | None = None,
+    activity_type: str | None = None,
+) -> tuple[list[dict], int]:
+    """Query activities with pagination and filtering.
+
+    Args:
+        limit: Maximum number of results to return
+        offset: Number of results to skip
+        start_date: Filter activities starting on or after this date (YYYY-MM-DD)
+        end_date: Filter activities ending on or before this date (YYYY-MM-DD)
+        wbs_id: Filter by WBS ID
+        activity_type: Filter by task type (TT_Task, TT_Mile, etc.)
+
+    Returns:
+        Tuple of (list of activity dicts, total count matching filters)
+    """
+    # Build WHERE clause
+    conditions = []
+    params: list = []
+
+    if start_date:
+        conditions.append("target_start_date >= ?")
+        params.append(f"{start_date}T00:00:00")
+
+    if end_date:
+        conditions.append("target_end_date <= ?")
+        params.append(f"{end_date}T23:59:59")
+
+    if wbs_id:
+        conditions.append("wbs_id = ?")
+        params.append(wbs_id)
+
+    if activity_type:
+        conditions.append("task_type = ?")
+        params.append(activity_type)
+
+    where_clause = " AND ".join(conditions) if conditions else "1=1"
+
+    # Get total count
+    with db.cursor() as cur:
+        cur.execute(f"SELECT COUNT(*) FROM activities WHERE {where_clause}", params)  # noqa: S608
+        total = cur.fetchone()[0]
+
+    # Get paginated results
+    query = f"""
+        SELECT task_id, task_code, task_name, task_type,
+               target_start_date, target_end_date, status_code,
+               driving_path_flag, wbs_id, total_float_hr_cnt
+        FROM activities
+        WHERE {where_clause}
+        ORDER BY target_start_date, task_code
+        LIMIT ? OFFSET ?
+    """  # noqa: S608
+
+    with db.cursor() as cur:
+        cur.execute(query, [*params, limit, offset])
+        rows = cur.fetchall()
+
+    activities = [
+        {
+            "task_id": row[0],
+            "task_code": row[1],
+            "task_name": row[2],
+            "task_type": row[3],
+            "target_start_date": row[4],
+            "target_end_date": row[5],
+            "status_code": row[6],
+            "driving_path_flag": bool(row[7]),
+        }
+        for row in rows
+    ]
+
+    return activities, total
+
+
+def get_activity_by_id(activity_id: str) -> dict | None:
+    """Get a single activity by ID with full details.
+
+    Args:
+        activity_id: The task_id to look up
+
+    Returns:
+        Activity dict with all fields, or None if not found
+    """
+    query = """
+        SELECT a.task_id, a.task_code, a.task_name, a.task_type,
+               a.wbs_id, w.wbs_name,
+               a.target_start_date, a.target_end_date,
+               a.act_start_date, a.act_end_date,
+               a.total_float_hr_cnt, a.status_code, a.driving_path_flag
+        FROM activities a
+        LEFT JOIN wbs w ON a.wbs_id = w.wbs_id
+        WHERE a.task_id = ?
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query, (activity_id,))
+        row = cur.fetchone()
+
+    if row is None:
+        return None
+
+    # Count predecessors and successors
+    with db.cursor() as cur:
+        cur.execute(
+            "SELECT COUNT(*) FROM relationships WHERE task_id = ?",
+            (activity_id,),
+        )
+        predecessor_count = cur.fetchone()[0]
+
+        cur.execute(
+            "SELECT COUNT(*) FROM relationships WHERE pred_task_id = ?",
+            (activity_id,),
+        )
+        successor_count = cur.fetchone()[0]
+
+    return {
+        "task_id": row[0],
+        "task_code": row[1],
+        "task_name": row[2],
+        "task_type": row[3],
+        "wbs_id": row[4],
+        "wbs_name": row[5],
+        "target_start_date": row[6],
+        "target_end_date": row[7],
+        "act_start_date": row[8],
+        "act_end_date": row[9],
+        "total_float_hr_cnt": row[10],
+        "status_code": row[11],
+        "driving_path_flag": bool(row[12]),
+        "predecessor_count": predecessor_count,
+        "successor_count": successor_count,
+    }
+
+
+def query_relationships(
+    limit: int = 100,
+    offset: int = 0,
+) -> tuple[list[dict], int]:
+    """Query relationships with pagination.
+
+    Args:
+        limit: Maximum number of results to return
+        offset: Number of results to skip
+
+    Returns:
+        Tuple of (list of relationship dicts, total count)
+    """
+    # Get total count
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM relationships")
+        total = cur.fetchone()[0]
+
+    # Get paginated results with activity names
+    query = """
+        SELECT r.task_pred_id, r.task_id, a1.task_name,
+               r.pred_task_id, a2.task_name,
+               r.pred_type, r.lag_hr_cnt
+        FROM relationships r
+        LEFT JOIN activities a1 ON r.task_id = a1.task_id
+        LEFT JOIN activities a2 ON r.pred_task_id = a2.task_id
+        ORDER BY r.task_pred_id
+        LIMIT ? OFFSET ?
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query, (limit, offset))
+        rows = cur.fetchall()
+
+    # Convert pred_type from internal format (PR_FS) to API format (FS)
+    def format_pred_type(pred_type: str) -> str:
+        if pred_type.startswith("PR_"):
+            return pred_type[3:]
+        return pred_type
+
+    relationships = [
+        {
+            "task_pred_id": row[0],
+            "task_id": row[1],
+            "task_name": row[2],
+            "pred_task_id": row[3],
+            "pred_task_name": row[4],
+            "pred_type": format_pred_type(row[5]),
+            "lag_hr_cnt": row[6],
+        }
+        for row in rows
+    ]
+
+    return relationships, total
+
+
+def get_predecessors(activity_id: str) -> list[dict]:
+    """Get predecessor activities for a given activity.
+
+    Args:
+        activity_id: The task_id to find predecessors for
+
+    Returns:
+        List of predecessor activity dicts with relationship info
+    """
+    query = """
+        SELECT a.task_id, a.task_code, a.task_name,
+               r.pred_type, r.lag_hr_cnt
+        FROM relationships r
+        JOIN activities a ON r.pred_task_id = a.task_id
+        WHERE r.task_id = ?
+        ORDER BY a.task_code
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query, (activity_id,))
+        rows = cur.fetchall()
+
+    def format_pred_type(pred_type: str) -> str:
+        if pred_type.startswith("PR_"):
+            return pred_type[3:]
+        return pred_type
+
+    return [
+        {
+            "task_id": row[0],
+            "task_code": row[1],
+            "task_name": row[2],
+            "relationship_type": format_pred_type(row[3]),
+            "lag_hr_cnt": row[4],
+        }
+        for row in rows
+    ]
+
+
+def get_successors(activity_id: str) -> list[dict]:
+    """Get successor activities for a given activity.
+
+    Args:
+        activity_id: The task_id to find successors for
+
+    Returns:
+        List of successor activity dicts with relationship info
+    """
+    query = """
+        SELECT a.task_id, a.task_code, a.task_name,
+               r.pred_type, r.lag_hr_cnt
+        FROM relationships r
+        JOIN activities a ON r.task_id = a.task_id
+        WHERE r.pred_task_id = ?
+        ORDER BY a.task_code
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query, (activity_id,))
+        rows = cur.fetchall()
+
+    def format_pred_type(pred_type: str) -> str:
+        if pred_type.startswith("PR_"):
+            return pred_type[3:]
+        return pred_type
+
+    return [
+        {
+            "task_id": row[0],
+            "task_code": row[1],
+            "task_name": row[2],
+            "relationship_type": format_pred_type(row[3]),
+            "lag_hr_cnt": row[4],
+        }
+        for row in rows
+    ]
+
+
+def get_project_summary(project_id: str) -> dict | None:
+    """Get project summary information.
+
+    Args:
+        project_id: The project ID to get summary for
+
+    Returns:
+        Dictionary with project summary or None if not found
+    """
+    # Get project info
+    with db.cursor() as cur:
+        cur.execute(
+            """
+            SELECT proj_id, proj_short_name, plan_start_date, plan_end_date
+            FROM projects
+            WHERE proj_id = ?
+            """,
+            (project_id,),
+        )
+        project_row = cur.fetchone()
+
+    if project_row is None:
+        return None
+
+    # Get activity count
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM activities")
+        activity_count = cur.fetchone()[0]
+
+    # Get milestone count
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM activities WHERE task_type = 'TT_Mile'")
+        milestone_count = cur.fetchone()[0]
+
+    # Get critical activity count
+    with db.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM activities WHERE driving_path_flag = 1")
+        critical_count = cur.fetchone()[0]
+
+    return {
+        "project_id": project_row[0],
+        "project_name": project_row[1],
+        "plan_start_date": project_row[2],
+        "plan_end_date": project_row[3],
+        "activity_count": activity_count,
+        "milestone_count": milestone_count,
+        "critical_activity_count": critical_count,
+    }
+
+
+def query_milestones() -> list[dict]:
+    """Query all milestone activities.
+
+    Returns:
+        List of milestone activity dicts
+    """
+    query = """
+        SELECT task_id, task_code, task_name,
+               target_start_date, target_end_date, status_code
+        FROM activities
+        WHERE task_type = 'TT_Mile'
+        ORDER BY target_start_date, task_code
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query)
+        rows = cur.fetchall()
+
+    return [
+        {
+            "task_id": row[0],
+            "task_code": row[1],
+            "task_name": row[2],
+            "target_start_date": row[3],
+            "target_end_date": row[4],
+            "status_code": row[5],
+        }
+        for row in rows
+    ]
+
+
+def query_critical_path() -> list[dict]:
+    """Query all activities on the critical path.
+
+    Returns:
+        List of critical path activity dicts ordered by start date
+    """
+    query = """
+        SELECT task_id, task_code, task_name, task_type,
+               target_start_date, target_end_date,
+               total_float_hr_cnt, status_code
+        FROM activities
+        WHERE driving_path_flag = 1
+        ORDER BY target_start_date, task_code
+    """
+
+    with db.cursor() as cur:
+        cur.execute(query)
+        rows = cur.fetchall()
+
+    return [
+        {
+            "task_id": row[0],
+            "task_code": row[1],
+            "task_name": row[2],
+            "task_type": row[3],
+            "target_start_date": row[4],
+            "target_end_date": row[5],
+            "total_float_hr_cnt": row[6],
+            "status_code": row[7],
+        }
+        for row in rows
+    ]

src/xer_mcp/db/schema.py

@@ -0,0 +1,77 @@
+"""SQLite database schema for XER MCP Server."""
+
+SCHEMA_SQL = """
+-- Projects
+CREATE TABLE IF NOT EXISTS projects (
+    proj_id TEXT PRIMARY KEY,
+    proj_short_name TEXT NOT NULL,
+    plan_start_date TEXT,
+    plan_end_date TEXT,
+    loaded_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Activities
+CREATE TABLE IF NOT EXISTS activities (
+    task_id TEXT PRIMARY KEY,
+    proj_id TEXT NOT NULL,
+    wbs_id TEXT,
+    task_code TEXT NOT NULL,
+    task_name TEXT NOT NULL,
+    task_type TEXT NOT NULL,
+    target_start_date TEXT,
+    target_end_date TEXT,
+    act_start_date TEXT,
+    act_end_date TEXT,
+    total_float_hr_cnt REAL,
+    driving_path_flag INTEGER DEFAULT 0,
+    status_code TEXT,
+    FOREIGN KEY (proj_id) REFERENCES projects(proj_id)
+);
+
+-- Relationships
+CREATE TABLE IF NOT EXISTS relationships (
+    task_pred_id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL,
+    pred_task_id TEXT NOT NULL,
+    pred_type TEXT NOT NULL,
+    lag_hr_cnt REAL DEFAULT 0,
+    FOREIGN KEY (task_id) REFERENCES activities(task_id),
+    FOREIGN KEY (pred_task_id) REFERENCES activities(task_id)
+);
+
+-- WBS (Work Breakdown Structure)
+CREATE TABLE IF NOT EXISTS wbs (
+    wbs_id TEXT PRIMARY KEY,
+    proj_id TEXT NOT NULL,
+    parent_wbs_id TEXT,
+    wbs_short_name TEXT NOT NULL,
+    wbs_name TEXT,
+    FOREIGN KEY (proj_id) REFERENCES projects(proj_id),
+    FOREIGN KEY (parent_wbs_id) REFERENCES wbs(wbs_id)
+);
+
+-- Calendars (internal use only)
+CREATE TABLE IF NOT EXISTS calendars (
+    clndr_id TEXT PRIMARY KEY,
+    clndr_name TEXT NOT NULL,
+    day_hr_cnt REAL,
+    week_hr_cnt REAL
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_activities_proj ON activities(proj_id);
+CREATE INDEX IF NOT EXISTS idx_activities_wbs ON activities(wbs_id);
+CREATE INDEX IF NOT EXISTS idx_activities_type ON activities(task_type);
+CREATE INDEX IF NOT EXISTS idx_activities_critical ON activities(driving_path_flag)
+    WHERE driving_path_flag = 1;
+CREATE INDEX IF NOT EXISTS idx_activities_dates ON activities(target_start_date, target_end_date);
+CREATE INDEX IF NOT EXISTS idx_relationships_task ON relationships(task_id);
+CREATE INDEX IF NOT EXISTS idx_relationships_pred ON relationships(pred_task_id);
+CREATE INDEX IF NOT EXISTS idx_wbs_parent ON wbs(parent_wbs_id);
+CREATE INDEX IF NOT EXISTS idx_wbs_proj ON wbs(proj_id);
+"""
+
+
+def get_schema() -> str:
+    """Return the complete SQLite schema."""
+    return SCHEMA_SQL

src/xer_mcp/errors.py

@@ -0,0 +1,58 @@
+"""Error types for XER MCP Server."""
+
+
+class XerMcpError(Exception):
+    """Base exception for XER MCP Server."""
+
+    def __init__(self, code: str, message: str) -> None:
+        self.code = code
+        self.message = message
+        super().__init__(f"{code}: {message}")
+
+
+class FileNotFoundError(XerMcpError):
+    """Raised when the specified XER file does not exist."""
+
+    def __init__(self, file_path: str) -> None:
+        super().__init__(
+            "FILE_NOT_FOUND",
+            f"XER file not found: {file_path}",
+        )
+
+
+class ParseError(XerMcpError):
+    """Raised when the XER file cannot be parsed."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__("PARSE_ERROR", message)
+
+
+class NoFileLoadedError(XerMcpError):
+    """Raised when a query is attempted before loading an XER file."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "NO_FILE_LOADED",
+            "No XER file is loaded. Use the load_xer tool first.",
+        )
+
+
+class ProjectSelectionRequiredError(XerMcpError):
+    """Raised when a multi-project file requires explicit project selection."""
+
+    def __init__(self, available_projects: list[dict]) -> None:
+        self.available_projects = available_projects
+        super().__init__(
+            "PROJECT_SELECTION_REQUIRED",
+            "Multiple projects found. Please specify project_id.",
+        )
+
+
+class ActivityNotFoundError(XerMcpError):
+    """Raised when the specified activity does not exist."""
+
+    def __init__(self, activity_id: str) -> None:
+        super().__init__(
+            "ACTIVITY_NOT_FOUND",
+            f"Activity not found: {activity_id}",
+        )

src/xer_mcp/models/__init__.py

@@ -0,0 +1,17 @@
+"""Data models for XER MCP Server."""
+
+from xer_mcp.models.activity import Activity
+from xer_mcp.models.calendar import Calendar
+from xer_mcp.models.pagination import PaginationMetadata
+from xer_mcp.models.project import Project
+from xer_mcp.models.relationship import Relationship
+from xer_mcp.models.wbs import WBS
+
+__all__ = [
+    "Activity",
+    "Calendar",
+    "PaginationMetadata",
+    "Project",
+    "Relationship",
+    "WBS",
+]

src/xer_mcp/models/activity.py

@@ -0,0 +1,23 @@
+"""Activity data model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class Activity:
+    """A unit of work in the schedule."""
+
+    task_id: str
+    proj_id: str
+    task_code: str
+    task_name: str
+    task_type: str
+    wbs_id: str | None = None
+    target_start_date: datetime | None = None
+    target_end_date: datetime | None = None
+    act_start_date: datetime | None = None
+    act_end_date: datetime | None = None
+    total_float_hr_cnt: float | None = None
+    driving_path_flag: bool = False
+    status_code: str | None = None

src/xer_mcp/models/calendar.py

@@ -0,0 +1,13 @@
+"""Calendar data model (internal use only)."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Calendar:
+    """Work schedule definition. Not exposed via MCP tools."""
+
+    clndr_id: str
+    clndr_name: str
+    day_hr_cnt: float | None = None
+    week_hr_cnt: float | None = None

src/xer_mcp/models/pagination.py

@@ -0,0 +1,13 @@
+"""Pagination metadata model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PaginationMetadata:
+    """Response wrapper for paginated queries."""
+
+    total_count: int
+    offset: int
+    limit: int
+    has_more: bool

src/xer_mcp/models/project.py

@@ -0,0 +1,15 @@
+"""Project data model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class Project:
+    """Top-level container representing a P6 project."""
+
+    proj_id: str
+    proj_short_name: str
+    plan_start_date: datetime | None = None
+    plan_end_date: datetime | None = None
+    loaded_at: datetime | None = None

src/xer_mcp/models/relationship.py

@@ -0,0 +1,14 @@
+"""Relationship data model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Relationship:
+    """A dependency link between two activities."""
+
+    task_pred_id: str
+    task_id: str
+    pred_task_id: str
+    pred_type: str
+    lag_hr_cnt: float = 0.0

src/xer_mcp/models/wbs.py

@@ -0,0 +1,14 @@
+"""Work Breakdown Structure (WBS) data model."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class WBS:
+    """Hierarchical organization of activities."""
+
+    wbs_id: str
+    proj_id: str
+    wbs_short_name: str
+    parent_wbs_id: str | None = None
+    wbs_name: str | None = None

src/xer_mcp/parser/__init__.py

@@ -0,0 +1 @@
+"""XER file parser module."""

src/xer_mcp/parser/table_handlers/__init__.py

@@ -0,0 +1,27 @@
+"""XER table handlers module."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+from xer_mcp.parser.table_handlers.calendar import CalendarHandler
+from xer_mcp.parser.table_handlers.project import ProjectHandler
+from xer_mcp.parser.table_handlers.projwbs import ProjwbsHandler
+from xer_mcp.parser.table_handlers.task import TaskHandler
+from xer_mcp.parser.table_handlers.taskpred import TaskpredHandler
+
+# Registry mapping table names to handlers
+TABLE_HANDLERS: dict[str, type[TableHandler]] = {
+    "PROJECT": ProjectHandler,
+    "TASK": TaskHandler,
+    "TASKPRED": TaskpredHandler,
+    "PROJWBS": ProjwbsHandler,
+    "CALENDAR": CalendarHandler,
+}
+
+__all__ = [
+    "CalendarHandler",
+    "ProjectHandler",
+    "ProjwbsHandler",
+    "TABLE_HANDLERS",
+    "TableHandler",
+    "TaskHandler",
+    "TaskpredHandler",
+]

src/xer_mcp/parser/table_handlers/base.py

@@ -0,0 +1,30 @@
+"""Base class for XER table handlers."""
+
+from abc import ABC, abstractmethod
+
+
+class TableHandler(ABC):
+    """Abstract base class for XER table handlers.
+
+    Each handler is responsible for parsing a specific table type
+    from the XER file and returning structured data.
+    """
+
+    @property
+    @abstractmethod
+    def table_name(self) -> str:
+        """Return the XER table name this handler processes (e.g., 'PROJECT', 'TASK')."""
+        ...
+
+    @abstractmethod
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a single row of data from the XER file.
+
+        Args:
+            fields: List of column names from the %F line
+            values: List of values from the %R line
+
+        Returns:
+            Dictionary of parsed data, or None if the row should be skipped
+        """
+        ...

src/xer_mcp/parser/table_handlers/calendar.py

@@ -0,0 +1,32 @@
+"""CALENDAR table handler."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+
+
+class CalendarHandler(TableHandler):
+    """Handler for CALENDAR table in XER files."""
+
+    @property
+    def table_name(self) -> str:
+        return "CALENDAR"
+
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a CALENDAR row."""
+        if len(values) < len(fields):
+            values = values + [""] * (len(fields) - len(values))
+
+        data = dict(zip(fields, values, strict=False))
+
+        # Parse numeric fields
+        day_hr_str = data.get("day_hr_cnt", "")
+        day_hr = float(day_hr_str) if day_hr_str else None
+
+        week_hr_str = data.get("week_hr_cnt", "")
+        week_hr = float(week_hr_str) if week_hr_str else None
+
+        return {
+            "clndr_id": data.get("clndr_id", ""),
+            "clndr_name": data.get("clndr_name", ""),
+            "day_hr_cnt": day_hr,
+            "week_hr_cnt": week_hr,
+        }

src/xer_mcp/parser/table_handlers/project.py

@@ -0,0 +1,38 @@
+"""PROJECT table handler."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+
+
+def convert_date(date_str: str | None) -> str | None:
+    """Convert XER date format to ISO8601.
+
+    XER format: "YYYY-MM-DD HH:MM"
+    ISO8601 format: "YYYY-MM-DDTHH:MM:SS"
+    """
+    if not date_str or date_str.strip() == "":
+        return None
+    # Replace space with T and add seconds
+    return date_str.replace(" ", "T") + ":00"
+
+
+class ProjectHandler(TableHandler):
+    """Handler for PROJECT table in XER files."""
+
+    @property
+    def table_name(self) -> str:
+        return "PROJECT"
+
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a PROJECT row."""
+        if len(values) < len(fields):
+            # Pad with empty strings if needed
+            values = values + [""] * (len(fields) - len(values))
+
+        data = dict(zip(fields, values, strict=False))
+
+        return {
+            "proj_id": data.get("proj_id", ""),
+            "proj_short_name": data.get("proj_short_name", ""),
+            "plan_start_date": convert_date(data.get("plan_start_date")),
+            "plan_end_date": convert_date(data.get("plan_end_date")),
+        }

src/xer_mcp/parser/table_handlers/projwbs.py

@@ -0,0 +1,26 @@
+"""PROJWBS table handler."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+
+
+class ProjwbsHandler(TableHandler):
+    """Handler for PROJWBS (WBS) table in XER files."""
+
+    @property
+    def table_name(self) -> str:
+        return "PROJWBS"
+
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a PROJWBS row."""
+        if len(values) < len(fields):
+            values = values + [""] * (len(fields) - len(values))
+
+        data = dict(zip(fields, values, strict=False))
+
+        return {
+            "wbs_id": data.get("wbs_id", ""),
+            "proj_id": data.get("proj_id", ""),
+            "parent_wbs_id": data.get("parent_wbs_id", ""),
+            "wbs_short_name": data.get("wbs_short_name", ""),
+            "wbs_name": data.get("wbs_name") or None,
+        }

src/xer_mcp/parser/table_handlers/task.py

@@ -0,0 +1,43 @@
+"""TASK table handler."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+from xer_mcp.parser.table_handlers.project import convert_date
+
+
+class TaskHandler(TableHandler):
+    """Handler for TASK table in XER files."""
+
+    @property
+    def table_name(self) -> str:
+        return "TASK"
+
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a TASK row."""
+        if len(values) < len(fields):
+            values = values + [""] * (len(fields) - len(values))
+
+        data = dict(zip(fields, values, strict=False))
+
+        # Parse driving_path_flag (Y/N -> bool)
+        driving_flag = data.get("driving_path_flag", "N")
+        driving_path = driving_flag.upper() == "Y" if driving_flag else False
+
+        # Parse total_float_hr_cnt
+        float_str = data.get("total_float_hr_cnt", "")
+        total_float = float(float_str) if float_str else None
+
+        return {
+            "task_id": data.get("task_id", ""),
+            "proj_id": data.get("proj_id", ""),
+            "wbs_id": data.get("wbs_id") or None,
+            "task_code": data.get("task_code", ""),
+            "task_name": data.get("task_name", ""),
+            "task_type": data.get("task_type", ""),
+            "status_code": data.get("status_code") or None,
+            "target_start_date": convert_date(data.get("target_start_date")),
+            "target_end_date": convert_date(data.get("target_end_date")),
+            "act_start_date": convert_date(data.get("act_start_date")),
+            "act_end_date": convert_date(data.get("act_end_date")),
+            "total_float_hr_cnt": total_float,
+            "driving_path_flag": driving_path,
+        }

src/xer_mcp/parser/table_handlers/taskpred.py

@@ -0,0 +1,31 @@
+"""TASKPRED table handler."""
+
+from xer_mcp.parser.table_handlers.base import TableHandler
+
+
+class TaskpredHandler(TableHandler):
+    """Handler for TASKPRED (relationships) table in XER files."""
+
+    @property
+    def table_name(self) -> str:
+        return "TASKPRED"
+
+    def parse_row(self, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a TASKPRED row."""
+        if len(values) < len(fields):
+            values = values + [""] * (len(fields) - len(values))
+
+        data = dict(zip(fields, values, strict=False))
+
+        # Parse lag_hr_cnt
+        lag_str = data.get("lag_hr_cnt", "0")
+        lag_hr = float(lag_str) if lag_str else 0.0
+
+        return {
+            "task_pred_id": data.get("task_pred_id", ""),
+            "task_id": data.get("task_id", ""),
+            "pred_task_id": data.get("pred_task_id", ""),
+            "proj_id": data.get("proj_id", ""),
+            "pred_type": data.get("pred_type", ""),
+            "lag_hr_cnt": lag_hr,
+        }

src/xer_mcp/parser/xer_parser.py

@@ -0,0 +1,127 @@
+"""XER file parser."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from xer_mcp.errors import FileNotFoundError, ParseError
+from xer_mcp.parser.table_handlers import TABLE_HANDLERS
+
+
+@dataclass
+class ParsedXer:
+    """Container for parsed XER data."""
+
+    projects: list[dict] = field(default_factory=list)
+    tasks: list[dict] = field(default_factory=list)
+    taskpreds: list[dict] = field(default_factory=list)
+    projwbs: list[dict] = field(default_factory=list)
+    calendars: list[dict] = field(default_factory=list)
+
+
+class XerParser:
+    """Parser for Primavera P6 XER files.
+
+    XER files are tab-delimited with the following structure:
+    - ERMHDR line: header with version info
+    - %T lines: table name declarations
+    - %F lines: field (column) names
+    - %R lines: data rows
+    """
+
+    def parse(self, file_path: Path | str) -> ParsedXer:
+        """Parse an XER file and return structured data.
+
+        Args:
+            file_path: Path to the XER file
+
+        Returns:
+            ParsedXer containing all parsed tables
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ParseError: If file is invalid or cannot be parsed
+        """
+        path = Path(file_path)
+        if not path.exists():
+            raise FileNotFoundError(str(path))
+
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+        except OSError as e:
+            raise ParseError(f"Cannot read file: {e}") from e
+
+        return self._parse_content(content)
+
+    def _parse_content(self, content: str) -> ParsedXer:
+        """Parse XER content string."""
+        lines = content.split("\n")
+        if not lines:
+            raise ParseError("Empty file")
+
+        # Check for ERMHDR line
+        first_line = lines[0].strip()
+        if not first_line.startswith("ERMHDR"):
+            raise ParseError("Invalid XER file: missing ERMHDR header")
+
+        result = ParsedXer()
+        current_table: str | None = None
+        current_fields: list[str] = []
+
+        for line in lines[1:]:
+            line = line.rstrip("\r\n")
+            if not line:
+                continue
+
+            parts = line.split("\t")
+            if not parts:
+                continue
+
+            marker = parts[0]
+
+            if marker == "%T":
+                # Table declaration
+                if len(parts) < 2:
+                    continue
+                current_table = parts[1]
+                current_fields = []
+
+            elif marker == "%F":
+                # Field names
+                current_fields = parts[1:]
+
+            elif marker == "%R":
+                # Data row
+                if current_table and current_fields:
+                    values = parts[1:]
+                    row_data = self._parse_row(current_table, current_fields, values)
+                    if row_data:
+                        self._add_to_result(result, current_table, row_data)
+
+        # Validate we got at least some data
+        if not result.projects:
+            raise ParseError("No PROJECT data found in XER file")
+
+        return result
+
+    def _parse_row(self, table_name: str, fields: list[str], values: list[str]) -> dict | None:
+        """Parse a single data row using the appropriate handler."""
+        handler_class = TABLE_HANDLERS.get(table_name)
+        if handler_class is None:
+            # Unknown table, skip
+            return None
+
+        handler = handler_class()
+        return handler.parse_row(fields, values)
+
+    def _add_to_result(self, result: ParsedXer, table_name: str, row_data: dict) -> None:
+        """Add parsed row to the appropriate result list."""
+        if table_name == "PROJECT":
+            result.projects.append(row_data)
+        elif table_name == "TASK":
+            result.tasks.append(row_data)
+        elif table_name == "TASKPRED":
+            result.taskpreds.append(row_data)
+        elif table_name == "PROJWBS":
+            result.projwbs.append(row_data)
+        elif table_name == "CALENDAR":
+            result.calendars.append(row_data)

src/xer_mcp/server.py

@@ -0,0 +1,273 @@
+"""MCP Server for XER file analysis."""
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from xer_mcp.db import db
+
+# Create MCP server instance
+server = Server("xer-mcp")
+
+# Server state
+_file_loaded: bool = False
+_current_project_id: str | None = None
+
+
+def is_file_loaded() -> bool:
+    """Check if an XER file has been loaded."""
+    return _file_loaded
+
+
+def get_current_project_id() -> str | None:
+    """Get the currently selected project ID."""
+    return _current_project_id
+
+
+def set_file_loaded(loaded: bool, project_id: str | None = None) -> None:
+    """Set the file loaded state."""
+    global _file_loaded, _current_project_id
+    _file_loaded = loaded
+    _current_project_id = project_id
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available MCP tools."""
+    return [
+        Tool(
+            name="load_xer",
+            description="Load a Primavera P6 XER file and parse its schedule data. "
+            "For multi-project files, specify project_id to select a project.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute path to the XER file",
+                    },
+                    "project_id": {
+                        "type": "string",
+                        "description": "Project ID to select (required for multi-project files)",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        ),
+        Tool(
+            name="list_activities",
+            description="List activities from the loaded XER file with optional filtering and pagination.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "start_date": {
+                        "type": "string",
+                        "format": "date",
+                        "description": "Filter activities starting on or after this date (YYYY-MM-DD)",
+                    },
+                    "end_date": {
+                        "type": "string",
+                        "format": "date",
+                        "description": "Filter activities ending on or before this date (YYYY-MM-DD)",
+                    },
+                    "wbs_id": {
+                        "type": "string",
+                        "description": "Filter by WBS element ID",
+                    },
+                    "activity_type": {
+                        "type": "string",
+                        "enum": ["TT_Task", "TT_Mile", "TT_LOE", "TT_WBS", "TT_Rsrc"],
+                        "description": "Filter by activity type",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "default": 100,
+                        "minimum": 1,
+                        "maximum": 1000,
+                        "description": "Maximum number of activities to return",
+                    },
+                    "offset": {
+                        "type": "integer",
+                        "default": 0,
+                        "minimum": 0,
+                        "description": "Number of activities to skip",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_activity",
+            description="Get detailed information for a specific activity by ID.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "activity_id": {
+                        "type": "string",
+                        "description": "The task_id of the activity",
+                    },
+                },
+                "required": ["activity_id"],
+            },
+        ),
+        Tool(
+            name="list_relationships",
+            description="List all activity relationships (dependencies) with pagination.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "default": 100,
+                        "minimum": 1,
+                        "maximum": 1000,
+                        "description": "Maximum number of relationships to return",
+                    },
+                    "offset": {
+                        "type": "integer",
+                        "default": 0,
+                        "minimum": 0,
+                        "description": "Number of relationships to skip",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="get_predecessors",
+            description="Get all predecessor activities for a given activity.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "activity_id": {
+                        "type": "string",
+                        "description": "The task_id of the activity",
+                    },
+                },
+                "required": ["activity_id"],
+            },
+        ),
+        Tool(
+            name="get_successors",
+            description="Get all successor activities for a given activity.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "activity_id": {
+                        "type": "string",
+                        "description": "The task_id of the activity",
+                    },
+                },
+                "required": ["activity_id"],
+            },
+        ),
+        Tool(
+            name="get_project_summary",
+            description="Get a summary of the loaded project including dates and activity counts.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="list_milestones",
+            description="List all milestone activities in the loaded project.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+        Tool(
+            name="get_critical_path",
+            description="Get all activities on the critical path that determine project duration.",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    """Handle MCP tool calls."""
+    import json
+
+    if name == "load_xer":
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(
+            file_path=arguments["file_path"],
+            project_id=arguments.get("project_id"),
+        )
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "list_activities":
+        from xer_mcp.tools.list_activities import list_activities
+
+        result = await list_activities(
+            start_date=arguments.get("start_date"),
+            end_date=arguments.get("end_date"),
+            wbs_id=arguments.get("wbs_id"),
+            activity_type=arguments.get("activity_type"),
+            limit=arguments.get("limit", 100),
+            offset=arguments.get("offset", 0),
+        )
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "get_activity":
+        from xer_mcp.tools.get_activity import get_activity
+
+        result = await get_activity(activity_id=arguments["activity_id"])
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "list_relationships":
+        from xer_mcp.tools.list_relationships import list_relationships
+
+        result = await list_relationships(
+            limit=arguments.get("limit", 100),
+            offset=arguments.get("offset", 0),
+        )
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "get_predecessors":
+        from xer_mcp.tools.get_predecessors import get_predecessors
+
+        result = await get_predecessors(activity_id=arguments["activity_id"])
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "get_successors":
+        from xer_mcp.tools.get_successors import get_successors
+
+        result = await get_successors(activity_id=arguments["activity_id"])
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "get_project_summary":
+        from xer_mcp.tools.get_project_summary import get_project_summary
+
+        result = await get_project_summary()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "list_milestones":
+        from xer_mcp.tools.list_milestones import list_milestones
+
+        result = await list_milestones()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    if name == "get_critical_path":
+        from xer_mcp.tools.get_critical_path import get_critical_path
+
+        result = await get_critical_path()
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    raise ValueError(f"Unknown tool: {name}")
+
+
+async def run_server() -> None:
+    """Run the MCP server with stdio transport."""
+    db.initialize()
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options(),
+        )

src/xer_mcp/tools/__init__.py

@@ -0,0 +1 @@
+"""MCP tools for XER file analysis."""

src/xer_mcp/tools/get_activity.py

@@ -0,0 +1,34 @@
+"""get_activity MCP tool implementation."""
+
+from xer_mcp.db.queries import get_activity_by_id
+from xer_mcp.server import is_file_loaded
+
+
+async def get_activity(activity_id: str) -> dict:
+    """Get detailed information for a specific activity by ID.
+
+    Args:
+        activity_id: The task_id of the activity
+
+    Returns:
+        Dictionary with complete activity details or error
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    activity = get_activity_by_id(activity_id)
+
+    if activity is None:
+        return {
+            "error": {
+                "code": "ACTIVITY_NOT_FOUND",
+                "message": f"Activity not found: {activity_id}",
+            }
+        }
+
+    return activity

src/xer_mcp/tools/get_critical_path.py

@@ -0,0 +1,36 @@
+"""get_critical_path MCP tool implementation."""
+
+from xer_mcp.db.queries import query_critical_path
+from xer_mcp.server import is_file_loaded
+
+
+async def get_critical_path() -> dict:
+    """Get all activities on the critical path.
+
+    Returns activities where driving_path_flag is set, ordered by target start date.
+    The critical path determines the minimum project duration.
+
+    Returns:
+        Dictionary with list of critical path activities, each containing:
+        - task_id: Activity ID
+        - task_code: Activity code
+        - task_name: Activity name
+        - task_type: Activity type (TT_Task, TT_Mile, etc.)
+        - target_start_date: Target start date
+        - target_end_date: Target end date
+        - total_float_hr_cnt: Total float in hours
+        - status_code: Activity status
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    critical_activities = query_critical_path()
+
+    return {
+        "critical_activities": critical_activities,
+    }

src/xer_mcp/tools/get_predecessors.py

@@ -0,0 +1,29 @@
+"""get_predecessors MCP tool implementation."""
+
+from xer_mcp.db.queries import get_predecessors as query_predecessors
+from xer_mcp.server import is_file_loaded
+
+
+async def get_predecessors(activity_id: str) -> dict:
+    """Get predecessor activities for a given activity.
+
+    Args:
+        activity_id: The task_id to find predecessors for
+
+    Returns:
+        Dictionary with activity_id and list of predecessor activities
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    predecessors = query_predecessors(activity_id)
+
+    return {
+        "activity_id": activity_id,
+        "predecessors": predecessors,
+    }

src/xer_mcp/tools/get_project_summary.py

@@ -0,0 +1,45 @@
+"""get_project_summary MCP tool implementation."""
+
+from xer_mcp.db.queries import get_project_summary as query_project_summary
+from xer_mcp.server import get_current_project_id, is_file_loaded
+
+
+async def get_project_summary() -> dict:
+    """Get a summary of the loaded project.
+
+    Returns:
+        Dictionary with project summary information including:
+        - project_name: Name of the project
+        - plan_start_date: Planned start date
+        - plan_end_date: Planned end date
+        - activity_count: Total number of activities
+        - milestone_count: Number of milestone activities
+        - critical_activity_count: Number of activities on critical path
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    project_id = get_current_project_id()
+    if project_id is None:
+        return {
+            "error": {
+                "code": "NO_PROJECT_SELECTED",
+                "message": "No project is selected.",
+            }
+        }
+
+    summary = query_project_summary(project_id)
+    if summary is None:
+        return {
+            "error": {
+                "code": "PROJECT_NOT_FOUND",
+                "message": f"Project with ID {project_id} not found.",
+            }
+        }
+
+    return summary

src/xer_mcp/tools/get_successors.py

@@ -0,0 +1,29 @@
+"""get_successors MCP tool implementation."""
+
+from xer_mcp.db.queries import get_successors as query_successors
+from xer_mcp.server import is_file_loaded
+
+
+async def get_successors(activity_id: str) -> dict:
+    """Get successor activities for a given activity.
+
+    Args:
+        activity_id: The task_id to find successors for
+
+    Returns:
+        Dictionary with activity_id and list of successor activities
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    successors = query_successors(activity_id)
+
+    return {
+        "activity_id": activity_id,
+        "successors": successors,
+    }

src/xer_mcp/tools/list_activities.py

@@ -0,0 +1,55 @@
+"""list_activities MCP tool implementation."""
+
+from xer_mcp.db.queries import query_activities
+from xer_mcp.server import is_file_loaded
+
+
+async def list_activities(
+    start_date: str | None = None,
+    end_date: str | None = None,
+    wbs_id: str | None = None,
+    activity_type: str | None = None,
+    limit: int = 100,
+    offset: int = 0,
+) -> dict:
+    """List activities from the loaded XER file with optional filtering.
+
+    Args:
+        start_date: Filter activities starting on or after this date (YYYY-MM-DD)
+        end_date: Filter activities ending on or before this date (YYYY-MM-DD)
+        wbs_id: Filter by WBS element ID
+        activity_type: Filter by activity type (TT_Task, TT_Mile, etc.)
+        limit: Maximum number of activities to return (default 100)
+        offset: Number of activities to skip (default 0)
+
+    Returns:
+        Dictionary with activities list and pagination metadata
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    activities, total_count = query_activities(
+        limit=limit,
+        offset=offset,
+        start_date=start_date,
+        end_date=end_date,
+        wbs_id=wbs_id,
+        activity_type=activity_type,
+    )
+
+    has_more = (offset + len(activities)) < total_count
+
+    return {
+        "activities": activities,
+        "pagination": {
+            "total_count": total_count,
+            "offset": offset,
+            "limit": limit,
+            "has_more": has_more,
+        },
+    }

src/xer_mcp/tools/list_milestones.py

@@ -0,0 +1,31 @@
+"""list_milestones MCP tool implementation."""
+
+from xer_mcp.db.queries import query_milestones
+from xer_mcp.server import is_file_loaded
+
+
+async def list_milestones() -> dict:
+    """List all milestone activities in the loaded project.
+
+    Returns:
+        Dictionary with list of milestones, each containing:
+        - task_id: Activity ID
+        - task_code: Activity code
+        - task_name: Activity name
+        - target_start_date: Target start date
+        - target_end_date: Target end date
+        - status_code: Activity status
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    milestones = query_milestones()
+
+    return {
+        "milestones": milestones,
+    }

src/xer_mcp/tools/list_relationships.py

@@ -0,0 +1,40 @@
+"""list_relationships MCP tool implementation."""
+
+from xer_mcp.db.queries import query_relationships
+from xer_mcp.server import is_file_loaded
+
+
+async def list_relationships(
+    limit: int = 100,
+    offset: int = 0,
+) -> dict:
+    """List all relationships (dependencies) with pagination.
+
+    Args:
+        limit: Maximum number of relationships to return (default 100)
+        offset: Number of relationships to skip (default 0)
+
+    Returns:
+        Dictionary with relationships list and pagination metadata
+    """
+    if not is_file_loaded():
+        return {
+            "error": {
+                "code": "NO_FILE_LOADED",
+                "message": "No XER file is loaded. Use the load_xer tool first.",
+            }
+        }
+
+    relationships, total_count = query_relationships(limit=limit, offset=offset)
+
+    has_more = (offset + len(relationships)) < total_count
+
+    return {
+        "relationships": relationships,
+        "pagination": {
+            "total_count": total_count,
+            "offset": offset,
+            "limit": limit,
+            "has_more": has_more,
+        },
+    }

src/xer_mcp/tools/load_xer.py

@@ -0,0 +1,86 @@
+"""load_xer MCP tool implementation."""
+
+from xer_mcp.db import db
+from xer_mcp.db.loader import get_activity_count, get_relationship_count, load_parsed_data
+from xer_mcp.errors import FileNotFoundError, ParseError
+from xer_mcp.parser.xer_parser import XerParser
+from xer_mcp.server import set_file_loaded
+
+
+async def load_xer(file_path: str, project_id: str | None = None) -> dict:
+    """Load a Primavera P6 XER file and parse its schedule data.
+
+    Args:
+        file_path: Absolute path to the XER file
+        project_id: Project ID to select (required for multi-project files)
+
+    Returns:
+        Dictionary with success status and project info or error details
+    """
+    # Ensure database is initialized
+    if not db.is_initialized:
+        db.initialize()
+
+    parser = XerParser()
+
+    try:
+        parsed = parser.parse(file_path)
+    except FileNotFoundError as e:
+        return {
+            "success": False,
+            "error": {"code": e.code, "message": e.message},
+        }
+    except ParseError as e:
+        return {
+            "success": False,
+            "error": {"code": e.code, "message": e.message},
+        }
+
+    # Handle multi-project files
+    if len(parsed.projects) > 1 and project_id is None:
+        available = [
+            {"proj_id": p["proj_id"], "proj_short_name": p["proj_short_name"]}
+            for p in parsed.projects
+        ]
+        return {
+            "success": False,
+            "available_projects": available,
+            "message": "Multiple projects found. Please specify project_id.",
+        }
+
+    # Auto-select if single project
+    if project_id is None:
+        project_id = parsed.projects[0]["proj_id"]
+
+    # Find the selected project
+    project = next((p for p in parsed.projects if p["proj_id"] == project_id), None)
+    if project is None:
+        return {
+            "success": False,
+            "error": {
+                "code": "PROJECT_NOT_FOUND",
+                "message": f"Project {project_id} not found in file",
+            },
+        }
+
+    # Load data into database
+    load_parsed_data(parsed, project_id)
+
+    # Mark file as loaded
+    set_file_loaded(True, project_id)
+
+    # Get counts
+    activity_count = get_activity_count()
+    relationship_count = get_relationship_count()
+
+    return {
+        "success": True,
+        "project": {
+            "proj_id": project["proj_id"],
+            "proj_short_name": project["proj_short_name"],
+            "plan_start_date": project["plan_start_date"],
+            "plan_end_date": project["plan_end_date"],
+        },
+        "activity_count": activity_count,
+        "relationship_count": relationship_count,
+    }

tests/__init__.py

@@ -0,0 +1 @@
+"""XER MCP Server tests."""

tests/conftest.py

@@ -0,0 +1,129 @@
+"""Pytest configuration and fixtures for XER MCP Server tests."""
+
+from pathlib import Path
+
+import pytest
+
+# Sample XER content for testing - minimal but complete
+SAMPLE_XER_SINGLE_PROJECT = """\
+ERMHDR\t21.12\t2026-01-06\tProject\tADMIN\ttestuser\tdbTest\tProject Management\tUSD
+%T\tPROJECT
+%F\tproj_id\tfy_start_month_num\trsrc_self_add_flag\tallow_complete_flag\trsrc_multi_assign_flag\tcheckout_flag\tproject_flag\tstep_complete_flag\tcost_qty_recalc_flag\tbatch_sum_flag\tname_sep_char\tdef_complete_pct_type\tproj_short_name\tacct_id\torig_proj_id\tsource_proj_id\tbase_type_id\tclndr_id\tsum_base_proj_id\ttask_code_base\ttask_code_step\tpriority_num\twbs_max_sum_level\tstrgy_priority_num\tlast_checksum\tcritical_drtn_hr_cnt\tdef_cost_per_qty\tlast_recalc_date\tplan_start_date\tplan_end_date\tscd_end_date\tadd_date\tlast_tasksum_date\tfcst_start_date\tdef_duration_type\ttask_code_prefix\tguid\tdef_qty_type\tadd_by_name\tweb_local_root_path\tproj_url\tdef_rate_type\tadd_act_remain_flag\tact_this_per_link_flag\tdef_task_type\tact_pct_link_flag\tcritical_path_type\ttask_code_prefix_flag\tdef_rollup_dates_flag\tuse_project_baseline_flag\trem_target_link_flag\treset_planned_flag\tallow_neg_act_flag\tsum_assign_level\tlast_fin_dates_id\tfintmpl_id\tlast_baseline_update_date\tcr_external_key\tapply_actuals_date\tlocation_id\tloaded_scope_level\texport_flag\tnew_fin_dates_id\tbaselines_to_export\tbaseline_names_to_export\tnext_data_date\tclose_period_flag\tsum_refresh_date\ttrsrcsum_loaded\tsumtask_loaded
+%R\t1001\t1\tY\tY\tY\tN\tY\tN\tN\tY\t.\tCP_Drtn\tTest Project\t\t\t\t\t1\t\t1000\t10\t10\t2\t500\t\t0\t0.0000\t2026-01-06 00:00\t2026-01-01 00:00\t2026-06-30 00:00\t2026-06-30 00:00\t2026-01-06 00:00\t\t\tDT_FixedDUR2\tA\ttest-guid-1\tQT_Hour\tADMIN\t\t\tCOST_PER_QTY\tN\tY\tTT_Task\tY\tCT_TotFloat\tY\tY\tY\tY\tN\tN\tSL_Taskrsrc\t\t1\t\t\t\t\t7\tY\t\t\t\t\t\t\t
+%T\tCALENDAR
+%F\tclndr_id\tdefault_flag\tclndr_name\tproj_id\tbase_clndr_id\tlast_chng_date\tclndr_type\tday_hr_cnt\tweek_hr_cnt\tmonth_hr_cnt\tyear_hr_cnt\trsrc_private\tclndr_data
+%R\t1\tY\tStandard 5 Day\t\t\t2026-01-06 00:00\tCA_Base\t8\t40\t160\t2080\tN\t
+%T\tPROJWBS
+%F\twbs_id\tproj_id\tobs_id\tseq_num\test_wt\tproj_node_flag\tsum_data_flag\tstatus_code\twbs_short_name\twbs_name\tphase_id\tparent_wbs_id\tev_user_pct\tev_etc_user_value\torig_cost\tindep_remain_total_cost\tann_dscnt_rate_pct\tdscnt_period_type\tindep_remain_work_qty\tanticip_start_date\tanticip_end_date\tev_compute_type\tev_etc_compute_type\tguid\ttmpl_guid\tplan_open_state
+%R\t100\t1001\t\t1\t1\tY\tN\tWS_Open\tROOT\tTest Project\t\t\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-1\t\t
+%R\t101\t1001\t\t1\t1\tN\tN\tWS_Open\tPH1\tPhase 1\t\t100\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-2\t\t
+%R\t102\t1001\t\t2\t1\tN\tN\tWS_Open\tPH2\tPhase 2\t\t100\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-3\t\t
+%T\tTASK
+%F\ttask_id\tproj_id\twbs_id\tclndr_id\tphys_complete_pct\trev_fdbk_flag\test_wt\tlock_plan_flag\tauto_compute_act_flag\tcomplete_pct_type\ttask_type\tduration_type\tstatus_code\ttask_code\ttask_name\trsrc_id\ttotal_float_hr_cnt\tfree_float_hr_cnt\tremain_drtn_hr_cnt\tact_work_qty\tremain_work_qty\ttarget_work_qty\ttarget_drtn_hr_cnt\ttarget_equip_qty\tact_equip_qty\tremain_equip_qty\tcstr_date\tact_start_date\tact_end_date\tlate_start_date\tlate_end_date\texpect_end_date\tearly_start_date\tearly_end_date\trestart_date\treend_date\ttarget_start_date\ttarget_end_date\trem_late_start_date\trem_late_end_date\tcstr_type\tpriority_type\tsuspend_date\tresume_date\tfloat_path\tfloat_path_order\tguid\ttmpl_guid\tcstr_date2\tcstr_type2\tdriving_path_flag\tact_this_per_work_qty\tact_this_per_equip_qty\texternal_early_start_date\texternal_late_end_date\tcreate_date\tupdate_date\tcreate_user\tupdate_user\tlocation_id\tcrt_path_num
+%R\t2001\t1001\t101\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Mile\tDT_FixedDrtn\tTK_NotStart\tA1000\tProject Start\t\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t\t\t\t2026-01-01 07:00\t2026-01-01 07:00\t\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t2026-01-01 07:00\t\tPT_Normal\t\t\t1\t1\ttask-guid-1\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%R\t2002\t1001\t101\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Task\tDT_FixedDUR2\tTK_NotStart\tA1010\tSite Preparation\t\t0\t0\t40\t0\t0\t0\t40\t0\t0\t0\t\t\t\t2026-01-02 07:00\t2026-01-08 15:00\t\t2026-01-02 07:00\t2026-01-08 15:00\t2026-01-02 07:00\t2026-01-08 15:00\t2026-01-02 07:00\t2026-01-08 15:00\t2026-01-02 07:00\t2026-01-08 15:00\t\tPT_Normal\t\t\t1\t2\ttask-guid-2\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%R\t2003\t1001\t101\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Task\tDT_FixedDUR2\tTK_NotStart\tA1020\tFoundation Work\t\t80\t0\t80\t0\t0\t0\t80\t0\t0\t0\t\t\t\t2026-01-09 07:00\t2026-01-22 15:00\t\t2026-01-09 07:00\t2026-01-22 15:00\t2026-01-09 07:00\t2026-01-22 15:00\t2026-01-09 07:00\t2026-01-22 15:00\t2026-01-09 07:00\t2026-01-22 15:00\t\tPT_Normal\t\t\t1\t3\ttask-guid-3\t\t\t\tN\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%R\t2004\t1001\t102\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Task\tDT_FixedDUR2\tTK_NotStart\tA1030\tStructural Work\t\t0\t0\t160\t0\t0\t0\t160\t0\t0\t0\t\t\t\t2026-01-23 07:00\t2026-02-19 15:00\t\t2026-01-23 07:00\t2026-02-19 15:00\t2026-01-23 07:00\t2026-02-19 15:00\t2026-01-23 07:00\t2026-02-19 15:00\t2026-01-23 07:00\t2026-02-19 15:00\t\tPT_Normal\t\t\t1\t4\ttask-guid-4\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%R\t2005\t1001\t102\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Mile\tDT_FixedDrtn\tTK_NotStart\tA1040\tProject Complete\t\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t\t\t\t2026-02-20 07:00\t2026-02-20 07:00\t\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t2026-02-20 07:00\t\tPT_Normal\t\t\t1\t5\ttask-guid-5\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%T\tTASKPRED
+%F\ttask_pred_id\ttask_id\tpred_task_id\tproj_id\tpred_proj_id\tpred_type\tlag_hr_cnt\tcomments\tfloat_path\taref\tarls
+%R\t3001\t2002\t2001\t1001\t1001\tPR_FS\t0\t\t\t2026-01-01 07:00\t2026-01-02 07:00
+%R\t3002\t2003\t2002\t1001\t1001\tPR_FS\t0\t\t\t2026-01-08 15:00\t2026-01-09 07:00
+%R\t3003\t2004\t2003\t1001\t1001\tPR_FS\t0\t\t\t2026-01-22 15:00\t2026-01-23 07:00
+%R\t3004\t2005\t2004\t1001\t1001\tPR_FS\t0\t\t\t2026-02-19 15:00\t2026-02-20 07:00
+%R\t3005\t2004\t2002\t1001\t1001\tPR_SS\t40\t\t\t2026-01-02 07:00\t2026-01-08 07:00
+%T\tEND
+"""
+
+SAMPLE_XER_MULTI_PROJECT = """\
+ERMHDR\t21.12\t2026-01-06\tProject\tADMIN\ttestuser\tdbTest\tProject Management\tUSD
+%T\tPROJECT
+%F\tproj_id\tfy_start_month_num\trsrc_self_add_flag\tallow_complete_flag\trsrc_multi_assign_flag\tcheckout_flag\tproject_flag\tstep_complete_flag\tcost_qty_recalc_flag\tbatch_sum_flag\tname_sep_char\tdef_complete_pct_type\tproj_short_name\tacct_id\torig_proj_id\tsource_proj_id\tbase_type_id\tclndr_id\tsum_base_proj_id\ttask_code_base\ttask_code_step\tpriority_num\twbs_max_sum_level\tstrgy_priority_num\tlast_checksum\tcritical_drtn_hr_cnt\tdef_cost_per_qty\tlast_recalc_date\tplan_start_date\tplan_end_date\tscd_end_date\tadd_date\tlast_tasksum_date\tfcst_start_date\tdef_duration_type\ttask_code_prefix\tguid\tdef_qty_type\tadd_by_name\tweb_local_root_path\tproj_url\tdef_rate_type\tadd_act_remain_flag\tact_this_per_link_flag\tdef_task_type\tact_pct_link_flag\tcritical_path_type\ttask_code_prefix_flag\tdef_rollup_dates_flag\tuse_project_baseline_flag\trem_target_link_flag\treset_planned_flag\tallow_neg_act_flag\tsum_assign_level\tlast_fin_dates_id\tfintmpl_id\tlast_baseline_update_date\tcr_external_key\tapply_actuals_date\tlocation_id\tloaded_scope_level\texport_flag\tnew_fin_dates_id\tbaselines_to_export\tbaseline_names_to_export\tnext_data_date\tclose_period_flag\tsum_refresh_date\ttrsrcsum_loaded\tsumtask_loaded
+%R\t1001\t1\tY\tY\tY\tN\tY\tN\tN\tY\t.\tCP_Drtn\tProject Alpha\t\t\t\t\t1\t\t1000\t10\t10\t2\t500\t\t0\t0.0000\t2026-01-06 00:00\t2026-01-01 00:00\t2026-03-31 00:00\t2026-03-31 00:00\t2026-01-06 00:00\t\t\tDT_FixedDUR2\tA\ttest-guid-1\tQT_Hour\tADMIN\t\t\tCOST_PER_QTY\tN\tY\tTT_Task\tY\tCT_TotFloat\tY\tY\tY\tY\tN\tN\tSL_Taskrsrc\t\t1\t\t\t\t\t7\tY\t\t\t\t\t\t\t
+%R\t1002\t1\tY\tY\tY\tN\tY\tN\tN\tY\t.\tCP_Drtn\tProject Beta\t\t\t\t\t1\t\t1000\t10\t10\t2\t500\t\t0\t0.0000\t2026-01-06 00:00\t2026-04-01 00:00\t2026-06-30 00:00\t2026-06-30 00:00\t2026-01-06 00:00\t\t\tDT_FixedDUR2\tB\ttest-guid-2\tQT_Hour\tADMIN\t\t\tCOST_PER_QTY\tN\tY\tTT_Task\tY\tCT_TotFloat\tY\tY\tY\tY\tN\tN\tSL_Taskrsrc\t\t1\t\t\t\t\t7\tY\t\t\t\t\t\t\t
+%T\tCALENDAR
+%F\tclndr_id\tdefault_flag\tclndr_name\tproj_id\tbase_clndr_id\tlast_chng_date\tclndr_type\tday_hr_cnt\tweek_hr_cnt\tmonth_hr_cnt\tyear_hr_cnt\trsrc_private\tclndr_data
+%R\t1\tY\tStandard 5 Day\t\t\t2026-01-06 00:00\tCA_Base\t8\t40\t160\t2080\tN\t
+%T\tPROJWBS
+%F\twbs_id\tproj_id\tobs_id\tseq_num\test_wt\tproj_node_flag\tsum_data_flag\tstatus_code\twbs_short_name\twbs_name\tphase_id\tparent_wbs_id\tev_user_pct\tev_etc_user_value\torig_cost\tindep_remain_total_cost\tann_dscnt_rate_pct\tdscnt_period_type\tindep_remain_work_qty\tanticip_start_date\tanticip_end_date\tev_compute_type\tev_etc_compute_type\tguid\ttmpl_guid\tplan_open_state
+%R\t100\t1001\t\t1\t1\tY\tN\tWS_Open\tALPHA\tProject Alpha\t\t\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-1\t\t
+%R\t200\t1002\t\t1\t1\tY\tN\tWS_Open\tBETA\tProject Beta\t\t\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-2\t\t
+%T\tTASK
+%F\ttask_id\tproj_id\twbs_id\tclndr_id\tphys_complete_pct\trev_fdbk_flag\test_wt\tlock_plan_flag\tauto_compute_act_flag\tcomplete_pct_type\ttask_type\tduration_type\tstatus_code\ttask_code\ttask_name\trsrc_id\ttotal_float_hr_cnt\tfree_float_hr_cnt\tremain_drtn_hr_cnt\tact_work_qty\tremain_work_qty\ttarget_work_qty\ttarget_drtn_hr_cnt\ttarget_equip_qty\tact_equip_qty\tremain_equip_qty\tcstr_date\tact_start_date\tact_end_date\tlate_start_date\tlate_end_date\texpect_end_date\tearly_start_date\tearly_end_date\trestart_date\treend_date\ttarget_start_date\ttarget_end_date\trem_late_start_date\trem_late_end_date\tcstr_type\tpriority_type\tsuspend_date\tresume_date\tfloat_path\tfloat_path_order\tguid\ttmpl_guid\tcstr_date2\tcstr_type2\tdriving_path_flag\tact_this_per_work_qty\tact_this_per_equip_qty\texternal_early_start_date\texternal_late_end_date\tcreate_date\tupdate_date\tcreate_user\tupdate_user\tlocation_id\tcrt_path_num
+%R\t2001\t1001\t100\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Task\tDT_FixedDUR2\tTK_NotStart\tA1000\tAlpha Task 1\t\t0\t0\t40\t0\t0\t0\t40\t0\t0\t0\t\t\t\t2026-01-01 07:00\t2026-01-08 15:00\t\t2026-01-01 07:00\t2026-01-08 15:00\t2026-01-01 07:00\t2026-01-08 15:00\t2026-01-01 07:00\t2026-01-08 15:00\t2026-01-01 07:00\t2026-01-08 15:00\t\tPT_Normal\t\t\t\t\ttask-guid-1\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%R\t2002\t1002\t200\t1\t0\tN\t1\tN\tN\tCP_Drtn\tTT_Task\tDT_FixedDUR2\tTK_NotStart\tB1000\tBeta Task 1\t\t0\t0\t40\t0\t0\t0\t40\t0\t0\t0\t\t\t\t2026-04-01 07:00\t2026-04-08 15:00\t\t2026-04-01 07:00\t2026-04-08 15:00\t2026-04-01 07:00\t2026-04-08 15:00\t2026-04-01 07:00\t2026-04-08 15:00\t2026-04-01 07:00\t2026-04-08 15:00\t\tPT_Normal\t\t\t\t\ttask-guid-2\t\t\t\tY\t0\t0\t\t\t2026-01-06 00:00\t2026-01-06 00:00\tADMIN\tADMIN\t\t
+%T\tTASKPRED
+%F\ttask_pred_id\ttask_id\tpred_task_id\tproj_id\tpred_proj_id\tpred_type\tlag_hr_cnt\tcomments\tfloat_path\taref\tarls
+%T\tEND
+"""
+
+SAMPLE_XER_EMPTY = """\
+ERMHDR\t21.12\t2026-01-06\tProject\tADMIN\ttestuser\tdbTest\tProject Management\tUSD
+%T\tPROJECT
+%F\tproj_id\tfy_start_month_num\trsrc_self_add_flag\tallow_complete_flag\trsrc_multi_assign_flag\tcheckout_flag\tproject_flag\tstep_complete_flag\tcost_qty_recalc_flag\tbatch_sum_flag\tname_sep_char\tdef_complete_pct_type\tproj_short_name\tacct_id\torig_proj_id\tsource_proj_id\tbase_type_id\tclndr_id\tsum_base_proj_id\ttask_code_base\ttask_code_step\tpriority_num\twbs_max_sum_level\tstrgy_priority_num\tlast_checksum\tcritical_drtn_hr_cnt\tdef_cost_per_qty\tlast_recalc_date\tplan_start_date\tplan_end_date\tscd_end_date\tadd_date\tlast_tasksum_date\tfcst_start_date\tdef_duration_type\ttask_code_prefix\tguid\tdef_qty_type\tadd_by_name\tweb_local_root_path\tproj_url\tdef_rate_type\tadd_act_remain_flag\tact_this_per_link_flag\tdef_task_type\tact_pct_link_flag\tcritical_path_type\ttask_code_prefix_flag\tdef_rollup_dates_flag\tuse_project_baseline_flag\trem_target_link_flag\treset_planned_flag\tallow_neg_act_flag\tsum_assign_level\tlast_fin_dates_id\tfintmpl_id\tlast_baseline_update_date\tcr_external_key\tapply_actuals_date\tlocation_id\tloaded_scope_level\texport_flag\tnew_fin_dates_id\tbaselines_to_export\tbaseline_names_to_export\tnext_data_date\tclose_period_flag\tsum_refresh_date\ttrsrcsum_loaded\tsumtask_loaded
+%R\t1001\t1\tY\tY\tY\tN\tY\tN\tN\tY\t.\tCP_Drtn\tEmpty Project\t\t\t\t\t1\t\t1000\t10\t10\t2\t500\t\t0\t0.0000\t2026-01-06 00:00\t2026-01-01 00:00\t2026-06-30 00:00\t2026-06-30 00:00\t2026-01-06 00:00\t\t\tDT_FixedDUR2\tA\ttest-guid-1\tQT_Hour\tADMIN\t\t\tCOST_PER_QTY\tN\tY\tTT_Task\tY\tCT_TotFloat\tY\tY\tY\tY\tN\tN\tSL_Taskrsrc\t\t1\t\t\t\t\t7\tY\t\t\t\t\t\t\t
+%T\tCALENDAR
+%F\tclndr_id\tdefault_flag\tclndr_name\tproj_id\tbase_clndr_id\tlast_chng_date\tclndr_type\tday_hr_cnt\tweek_hr_cnt\tmonth_hr_cnt\tyear_hr_cnt\trsrc_private\tclndr_data
+%R\t1\tY\tStandard 5 Day\t\t\t2026-01-06 00:00\tCA_Base\t8\t40\t160\t2080\tN\t
+%T\tPROJWBS
+%F\twbs_id\tproj_id\tobs_id\tseq_num\test_wt\tproj_node_flag\tsum_data_flag\tstatus_code\twbs_short_name\twbs_name\tphase_id\tparent_wbs_id\tev_user_pct\tev_etc_user_value\torig_cost\tindep_remain_total_cost\tann_dscnt_rate_pct\tdscnt_period_type\tindep_remain_work_qty\tanticip_start_date\tanticip_end_date\tev_compute_type\tev_etc_compute_type\tguid\ttmpl_guid\tplan_open_state
+%R\t100\t1001\t\t1\t1\tY\tN\tWS_Open\tROOT\tEmpty Project\t\t\t6\t0.88\t0.0000\t0.0000\t\t\t\t\t\tEC_Cmp_pct\tEE_Rem_hr\twbs-guid-1\t\t
+%T\tTASK
+%F\ttask_id\tproj_id\twbs_id\tclndr_id\tphys_complete_pct\trev_fdbk_flag\test_wt\tlock_plan_flag\tauto_compute_act_flag\tcomplete_pct_type\ttask_type\tduration_type\tstatus_code\ttask_code\ttask_name\trsrc_id\ttotal_float_hr_cnt\tfree_float_hr_cnt\tremain_drtn_hr_cnt\tact_work_qty\tremain_work_qty\ttarget_work_qty\ttarget_drtn_hr_cnt\ttarget_equip_qty\tact_equip_qty\tremain_equip_qty\tcstr_date\tact_start_date\tact_end_date\tlate_start_date\tlate_end_date\texpect_end_date\tearly_start_date\tearly_end_date\trestart_date\treend_date\ttarget_start_date\ttarget_end_date\trem_late_start_date\trem_late_end_date\tcstr_type\tpriority_type\tsuspend_date\tresume_date\tfloat_path\tfloat_path_order\tguid\ttmpl_guid\tcstr_date2\tcstr_type2\tdriving_path_flag\tact_this_per_work_qty\tact_this_per_equip_qty\texternal_early_start_date\texternal_late_end_date\tcreate_date\tupdate_date\tcreate_user\tupdate_user\tlocation_id\tcrt_path_num
+%T\tTASKPRED
+%F\ttask_pred_id\ttask_id\tpred_task_id\tproj_id\tpred_proj_id\tpred_type\tlag_hr_cnt\tcomments\tfloat_path\taref\tarls
+%T\tEND
+"""
+
+
+@pytest.fixture
+def sample_xer_single_project(tmp_path: Path) -> Path:
+    """Create a temporary XER file with a single project."""
+    xer_file = tmp_path / "single_project.xer"
+    xer_file.write_text(SAMPLE_XER_SINGLE_PROJECT)
+    return xer_file
+
+
+@pytest.fixture
+def sample_xer_multi_project(tmp_path: Path) -> Path:
+    """Create a temporary XER file with multiple projects."""
+    xer_file = tmp_path / "multi_project.xer"
+    xer_file.write_text(SAMPLE_XER_MULTI_PROJECT)
+    return xer_file
+
+
+@pytest.fixture
+def sample_xer_empty(tmp_path: Path) -> Path:
+    """Create a temporary XER file with no activities."""
+    xer_file = tmp_path / "empty_project.xer"
+    xer_file.write_text(SAMPLE_XER_EMPTY)
+    return xer_file
+
+
+@pytest.fixture
+def nonexistent_xer_path(tmp_path: Path) -> Path:
+    """Return a path to a non-existent XER file."""
+    return tmp_path / "does_not_exist.xer"
+
+
+@pytest.fixture
+def invalid_xer_file(tmp_path: Path) -> Path:
+    """Create a temporary file with invalid XER content."""
+    xer_file = tmp_path / "invalid.xer"
+    xer_file.write_text("This is not a valid XER file\nJust some random text")
+    return xer_file
+
+
+@pytest.fixture
+def real_xer_file() -> Path | None:
+    """Return the path to the real XER file if it exists.
+
+    This fixture provides access to the actual XER file in the repository
+    for integration testing with real data.
+    """
+    real_file = Path(
+        "/home/bill/xer-mcp/S48019R - Proposal Schedule - E-J Electric Installation.xer"
+    )
+    if real_file.exists():
+        return real_file
+    return None

tests/contract/__init__.py

@@ -0,0 +1 @@
+"""Contract tests for MCP tool interfaces."""

tests/contract/test_get_activity.py

@@ -0,0 +1,89 @@
+"""Contract tests for get_activity MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestGetActivityContract:
+    """Contract tests verifying get_activity tool interface matches spec."""
+
+    async def test_get_activity_returns_details(self, sample_xer_single_project: Path) -> None:
+        """get_activity returns complete activity details."""
+        from xer_mcp.tools.get_activity import get_activity
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_activity(activity_id="2002")
+
+        assert result["task_id"] == "2002"
+        assert result["task_code"] == "A1010"
+        assert result["task_name"] == "Site Preparation"
+        assert result["task_type"] == "TT_Task"
+        assert "target_start_date" in result
+        assert "target_end_date" in result
+        assert "wbs_id" in result
+        assert "predecessor_count" in result
+        assert "successor_count" in result
+
+    async def test_get_activity_includes_wbs_name(self, sample_xer_single_project: Path) -> None:
+        """get_activity includes WBS name from lookup."""
+        from xer_mcp.tools.get_activity import get_activity
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_activity(activity_id="2002")
+
+        assert "wbs_name" in result
+
+    async def test_get_activity_includes_relationship_counts(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_activity includes predecessor and successor counts."""
+        from xer_mcp.tools.get_activity import get_activity
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # A1010 (2002) has 1 predecessor (A1000) and 2 successors (A1020, A1030)
+        result = await get_activity(activity_id="2002")
+
+        assert result["predecessor_count"] == 1
+        assert result["successor_count"] == 2
+
+    async def test_get_activity_not_found_returns_error(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_activity with invalid ID returns ACTIVITY_NOT_FOUND error."""
+        from xer_mcp.tools.get_activity import get_activity
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_activity(activity_id="nonexistent")
+
+        assert "error" in result
+        assert result["error"]["code"] == "ACTIVITY_NOT_FOUND"
+
+    async def test_get_activity_no_file_loaded_returns_error(self) -> None:
+        """get_activity without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.get_activity import get_activity
+
+        set_file_loaded(False)
+        result = await get_activity(activity_id="2002")
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_get_critical_path.py

@@ -0,0 +1,91 @@
+"""Contract tests for get_critical_path MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestGetCriticalPathContract:
+    """Contract tests verifying get_critical_path tool interface."""
+
+    async def test_get_critical_path_returns_critical_activities(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_critical_path returns activities with driving_path_flag set."""
+        from xer_mcp.tools.get_critical_path import get_critical_path
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_critical_path()
+
+        assert "critical_activities" in result
+        assert len(result["critical_activities"]) == 4
+
+    async def test_get_critical_path_includes_expected_fields(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_critical_path returns activities with required fields."""
+        from xer_mcp.tools.get_critical_path import get_critical_path
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_critical_path()
+
+        activity = result["critical_activities"][0]
+        assert "task_id" in activity
+        assert "task_code" in activity
+        assert "task_name" in activity
+        assert "target_start_date" in activity
+        assert "target_end_date" in activity
+        assert "total_float_hr_cnt" in activity
+
+    async def test_get_critical_path_ordered_by_date(self, sample_xer_single_project: Path) -> None:
+        """get_critical_path returns activities ordered by start date."""
+        from xer_mcp.tools.get_critical_path import get_critical_path
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_critical_path()
+
+        activities = result["critical_activities"]
+        for i in range(len(activities) - 1):
+            assert activities[i]["target_start_date"] <= activities[i + 1]["target_start_date"]
+
+    async def test_get_critical_path_excludes_non_critical(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_critical_path excludes activities not on critical path."""
+        from xer_mcp.tools.get_critical_path import get_critical_path
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_critical_path()
+
+        # A1020 "Foundation Work" has driving_path_flag = N
+        activity_names = [a["task_name"] for a in result["critical_activities"]]
+        assert "Foundation Work" not in activity_names
+
+    async def test_get_critical_path_no_file_loaded_returns_error(self) -> None:
+        """get_critical_path without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.get_critical_path import get_critical_path
+
+        set_file_loaded(False)
+        result = await get_critical_path()
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_get_predecessors.py

@@ -0,0 +1,77 @@
+"""Contract tests for get_predecessors MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestGetPredecessorsContract:
+    """Contract tests verifying get_predecessors tool interface."""
+
+    async def test_get_predecessors_returns_list(self, sample_xer_single_project: Path) -> None:
+        """get_predecessors returns predecessor activities."""
+        from xer_mcp.tools.get_predecessors import get_predecessors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # A1010 (2002) has one predecessor: A1000 (2001)
+        result = await get_predecessors(activity_id="2002")
+
+        assert "activity_id" in result
+        assert result["activity_id"] == "2002"
+        assert "predecessors" in result
+        assert len(result["predecessors"]) == 1
+        assert result["predecessors"][0]["task_id"] == "2001"
+
+    async def test_get_predecessors_includes_relationship_details(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_predecessors includes relationship type and lag."""
+        from xer_mcp.tools.get_predecessors import get_predecessors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_predecessors(activity_id="2002")
+
+        pred = result["predecessors"][0]
+        assert "relationship_type" in pred
+        assert "lag_hr_cnt" in pred
+        assert pred["relationship_type"] in ["FS", "SS", "FF", "SF"]
+
+    async def test_get_predecessors_empty_list_for_no_predecessors(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_predecessors returns empty list when no predecessors exist."""
+        from xer_mcp.tools.get_predecessors import get_predecessors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # A1000 (2001) has no predecessors
+        result = await get_predecessors(activity_id="2001")
+
+        assert "predecessors" in result
+        assert len(result["predecessors"]) == 0
+
+    async def test_get_predecessors_no_file_loaded_returns_error(self) -> None:
+        """get_predecessors without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.get_predecessors import get_predecessors
+
+        set_file_loaded(False)
+        result = await get_predecessors(activity_id="2002")
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_get_project_summary.py

@@ -0,0 +1,88 @@
+"""Contract tests for get_project_summary MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestGetProjectSummaryContract:
+    """Contract tests verifying get_project_summary tool interface."""
+
+    async def test_get_project_summary_returns_basic_info(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_project_summary returns project name, dates, and activity count."""
+        from xer_mcp.tools.get_project_summary import get_project_summary
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_project_summary()
+
+        assert "project_name" in result
+        assert "plan_start_date" in result
+        assert "plan_end_date" in result
+        assert "activity_count" in result
+
+    async def test_get_project_summary_returns_correct_values(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_project_summary returns correct project values from loaded XER."""
+        from xer_mcp.tools.get_project_summary import get_project_summary
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_project_summary()
+
+        assert result["project_name"] == "Test Project"
+        assert result["activity_count"] == 5
+
+    async def test_get_project_summary_includes_milestone_count(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_project_summary includes count of milestones."""
+        from xer_mcp.tools.get_project_summary import get_project_summary
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_project_summary()
+
+        assert "milestone_count" in result
+        assert result["milestone_count"] == 2
+
+    async def test_get_project_summary_includes_critical_count(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_project_summary includes count of critical path activities."""
+        from xer_mcp.tools.get_project_summary import get_project_summary
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_project_summary()
+
+        assert "critical_activity_count" in result
+        assert result["critical_activity_count"] == 4
+
+    async def test_get_project_summary_no_file_loaded_returns_error(self) -> None:
+        """get_project_summary without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.get_project_summary import get_project_summary
+
+        set_file_loaded(False)
+        result = await get_project_summary()
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_get_successors.py

@@ -0,0 +1,76 @@
+"""Contract tests for get_successors MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestGetSuccessorsContract:
+    """Contract tests verifying get_successors tool interface."""
+
+    async def test_get_successors_returns_list(self, sample_xer_single_project: Path) -> None:
+        """get_successors returns successor activities."""
+        from xer_mcp.tools.get_successors import get_successors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # A1010 (2002) has two successors: A1020 (2003) and A1030 (2004)
+        result = await get_successors(activity_id="2002")
+
+        assert "activity_id" in result
+        assert result["activity_id"] == "2002"
+        assert "successors" in result
+        assert len(result["successors"]) == 2
+
+    async def test_get_successors_includes_relationship_details(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_successors includes relationship type and lag."""
+        from xer_mcp.tools.get_successors import get_successors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await get_successors(activity_id="2001")
+
+        succ = result["successors"][0]
+        assert "relationship_type" in succ
+        assert "lag_hr_cnt" in succ
+        assert succ["relationship_type"] in ["FS", "SS", "FF", "SF"]
+
+    async def test_get_successors_empty_list_for_no_successors(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """get_successors returns empty list when no successors exist."""
+        from xer_mcp.tools.get_successors import get_successors
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # A1040 (2005) has no successors
+        result = await get_successors(activity_id="2005")
+
+        assert "successors" in result
+        assert len(result["successors"]) == 0
+
+    async def test_get_successors_no_file_loaded_returns_error(self) -> None:
+        """get_successors without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.get_successors import get_successors
+
+        set_file_loaded(False)
+        result = await get_successors(activity_id="2002")
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_list_activities.py

@@ -0,0 +1,138 @@
+"""Contract tests for list_activities MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestListActivitiesContract:
+    """Contract tests verifying list_activities tool interface matches spec."""
+
+    async def test_list_activities_returns_paginated_results(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_activities returns activities with pagination metadata."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities()
+
+        assert "activities" in result
+        assert "pagination" in result
+        assert len(result["activities"]) == 5
+        assert result["pagination"]["total_count"] == 5
+        assert result["pagination"]["offset"] == 0
+        assert result["pagination"]["limit"] == 100
+        assert result["pagination"]["has_more"] is False
+
+    async def test_list_activities_with_limit(self, sample_xer_single_project: Path) -> None:
+        """list_activities respects limit parameter."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities(limit=2)
+
+        assert len(result["activities"]) == 2
+        assert result["pagination"]["limit"] == 2
+        assert result["pagination"]["has_more"] is True
+
+    async def test_list_activities_with_offset(self, sample_xer_single_project: Path) -> None:
+        """list_activities respects offset parameter."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities(offset=2, limit=2)
+
+        assert len(result["activities"]) == 2
+        assert result["pagination"]["offset"] == 2
+
+    async def test_list_activities_filter_by_date_range(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_activities filters by date range."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        # Filter to January only
+        result = await list_activities(start_date="2026-01-01", end_date="2026-01-31")
+
+        # Should include activities in January
+        for activity in result["activities"]:
+            assert "2026-01" in activity["target_start_date"]
+
+    async def test_list_activities_filter_by_activity_type(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_activities filters by activity type."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities(activity_type="TT_Mile")
+
+        assert len(result["activities"]) == 2
+        for activity in result["activities"]:
+            assert activity["task_type"] == "TT_Mile"
+
+    async def test_list_activities_filter_by_wbs(self, sample_xer_single_project: Path) -> None:
+        """list_activities filters by WBS ID."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities(wbs_id="101")
+
+        # WBS 101 has 3 activities in the fixture
+        assert len(result["activities"]) == 3
+
+    async def test_list_activities_no_file_loaded_returns_error(self) -> None:
+        """list_activities without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.list_activities import list_activities
+
+        set_file_loaded(False)
+        result = await list_activities()
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"
+
+    async def test_list_activities_returns_expected_fields(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_activities returns activities with all expected fields."""
+        from xer_mcp.tools.list_activities import list_activities
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_activities()
+
+        activity = result["activities"][0]
+        assert "task_id" in activity
+        assert "task_code" in activity
+        assert "task_name" in activity
+        assert "task_type" in activity
+        assert "target_start_date" in activity
+        assert "target_end_date" in activity
+        assert "status_code" in activity
+        assert "driving_path_flag" in activity

tests/contract/test_list_milestones.py

@@ -0,0 +1,89 @@
+"""Contract tests for list_milestones MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestListMilestonesContract:
+    """Contract tests verifying list_milestones tool interface."""
+
+    async def test_list_milestones_returns_milestone_activities(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_milestones returns only milestone type activities."""
+        from xer_mcp.tools.list_milestones import list_milestones
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_milestones()
+
+        assert "milestones" in result
+        assert len(result["milestones"]) == 2
+
+    async def test_list_milestones_includes_expected_fields(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_milestones returns milestones with required fields."""
+        from xer_mcp.tools.list_milestones import list_milestones
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_milestones()
+
+        milestone = result["milestones"][0]
+        assert "task_id" in milestone
+        assert "task_code" in milestone
+        assert "task_name" in milestone
+        assert "target_start_date" in milestone
+        assert "target_end_date" in milestone
+
+    async def test_list_milestones_returns_correct_activities(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_milestones returns the expected milestone activities."""
+        from xer_mcp.tools.list_milestones import list_milestones
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_milestones()
+
+        milestone_names = [m["task_name"] for m in result["milestones"]]
+        assert "Project Start" in milestone_names
+        assert "Project Complete" in milestone_names
+
+    async def test_list_milestones_empty_when_no_milestones(self, sample_xer_empty: Path) -> None:
+        """list_milestones returns empty list when no milestones exist."""
+        from xer_mcp.tools.list_milestones import list_milestones
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_empty))
+
+        result = await list_milestones()
+
+        assert "milestones" in result
+        assert len(result["milestones"]) == 0
+
+    async def test_list_milestones_no_file_loaded_returns_error(self) -> None:
+        """list_milestones without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.list_milestones import list_milestones
+
+        set_file_loaded(False)
+        result = await list_milestones()
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_list_relationships.py

@@ -0,0 +1,78 @@
+"""Contract tests for list_relationships MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestListRelationshipsContract:
+    """Contract tests verifying list_relationships tool interface."""
+
+    async def test_list_relationships_returns_paginated_results(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_relationships returns relationships with pagination metadata."""
+        from xer_mcp.tools.list_relationships import list_relationships
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_relationships()
+
+        assert "relationships" in result
+        assert "pagination" in result
+        assert len(result["relationships"]) == 5
+        assert result["pagination"]["total_count"] == 5
+
+    async def test_list_relationships_with_pagination(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_relationships respects limit and offset parameters."""
+        from xer_mcp.tools.list_relationships import list_relationships
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_relationships(limit=2, offset=0)
+
+        assert len(result["relationships"]) == 2
+        assert result["pagination"]["has_more"] is True
+
+    async def test_list_relationships_includes_expected_fields(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """list_relationships returns relationships with all expected fields."""
+        from xer_mcp.tools.list_relationships import list_relationships
+        from xer_mcp.tools.load_xer import load_xer
+
+        await load_xer(file_path=str(sample_xer_single_project))
+
+        result = await list_relationships()
+
+        rel = result["relationships"][0]
+        assert "task_pred_id" in rel
+        assert "task_id" in rel
+        assert "pred_task_id" in rel
+        assert "pred_type" in rel
+        assert "lag_hr_cnt" in rel
+
+    async def test_list_relationships_no_file_loaded_returns_error(self) -> None:
+        """list_relationships without loaded file returns NO_FILE_LOADED error."""
+        from xer_mcp.server import set_file_loaded
+        from xer_mcp.tools.list_relationships import list_relationships
+
+        set_file_loaded(False)
+        result = await list_relationships()
+
+        assert "error" in result
+        assert result["error"]["code"] == "NO_FILE_LOADED"

tests/contract/test_load_xer.py

@@ -0,0 +1,107 @@
+"""Contract tests for load_xer MCP tool."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestLoadXerContract:
+    """Contract tests verifying load_xer tool interface matches spec."""
+
+    async def test_load_single_project_returns_success(
+        self, sample_xer_single_project: Path
+    ) -> None:
+        """load_xer with single-project file returns success and project info."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(sample_xer_single_project))
+
+        assert result["success"] is True
+        assert "project" in result
+        assert result["project"]["proj_id"] == "1001"
+        assert result["project"]["proj_short_name"] == "Test Project"
+        assert "activity_count" in result
+        assert result["activity_count"] == 5
+        assert "relationship_count" in result
+        assert result["relationship_count"] == 5
+
+    async def test_load_multi_project_without_selection_returns_list(
+        self, sample_xer_multi_project: Path
+    ) -> None:
+        """load_xer with multi-project file without project_id returns available projects."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(sample_xer_multi_project))
+
+        assert result["success"] is False
+        assert "available_projects" in result
+        assert len(result["available_projects"]) == 2
+        assert "message" in result
+        assert "project_id" in result["message"].lower()
+
+    async def test_load_multi_project_with_selection_returns_success(
+        self, sample_xer_multi_project: Path
+    ) -> None:
+        """load_xer with multi-project file and project_id returns selected project."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(sample_xer_multi_project), project_id="1001")
+
+        assert result["success"] is True
+        assert result["project"]["proj_id"] == "1001"
+        assert result["project"]["proj_short_name"] == "Project Alpha"
+
+    async def test_load_nonexistent_file_returns_error(self, nonexistent_xer_path: Path) -> None:
+        """load_xer with missing file returns FILE_NOT_FOUND error."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(nonexistent_xer_path))
+
+        assert result["success"] is False
+        assert "error" in result
+        assert result["error"]["code"] == "FILE_NOT_FOUND"
+
+    async def test_load_invalid_file_returns_error(self, invalid_xer_file: Path) -> None:
+        """load_xer with invalid file returns PARSE_ERROR error."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(invalid_xer_file))
+
+        assert result["success"] is False
+        assert "error" in result
+        assert result["error"]["code"] == "PARSE_ERROR"
+
+    async def test_load_replaces_previous_file(
+        self, sample_xer_single_project: Path, sample_xer_empty: Path
+    ) -> None:
+        """Loading a new file replaces the previous file's data."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        # Load first file
+        result1 = await load_xer(file_path=str(sample_xer_single_project))
+        assert result1["activity_count"] == 5
+
+        # Load second file (empty)
+        result2 = await load_xer(file_path=str(sample_xer_empty))
+        assert result2["activity_count"] == 0
+
+    async def test_load_returns_plan_dates(self, sample_xer_single_project: Path) -> None:
+        """load_xer returns project plan start and end dates."""
+        from xer_mcp.tools.load_xer import load_xer
+
+        result = await load_xer(file_path=str(sample_xer_single_project))
+
+        assert "plan_start_date" in result["project"]
+        assert "plan_end_date" in result["project"]
+        # Dates should be ISO8601 format
+        assert "T" in result["project"]["plan_start_date"]

tests/integration/__init__.py

@@ -0,0 +1 @@
+"""Integration tests for XER MCP Server."""

tests/integration/test_xer_parsing.py

@@ -0,0 +1,154 @@
+"""Integration tests for XER parsing and database loading."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestXerParsing:
+    """Integration tests for parsing XER files and loading into database."""
+
+    def test_load_single_project_xer(self, sample_xer_single_project: Path) -> None:
+        """Should parse XER and load data into SQLite database."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+
+        # Load all data for the single project
+        load_parsed_data(parsed, project_id="1001")
+
+        # Verify data in database
+        with db.cursor() as cur:
+            cur.execute("SELECT COUNT(*) FROM projects")
+            assert cur.fetchone()[0] == 1
+
+            cur.execute("SELECT COUNT(*) FROM activities")
+            assert cur.fetchone()[0] == 5
+
+            cur.execute("SELECT COUNT(*) FROM relationships")
+            assert cur.fetchone()[0] == 5
+
+            cur.execute("SELECT COUNT(*) FROM wbs")
+            assert cur.fetchone()[0] == 3
+
+    def test_load_preserves_date_precision(self, sample_xer_single_project: Path) -> None:
+        """Should preserve date/time precision from XER file."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            cur.execute("SELECT target_start_date FROM activities WHERE task_code = ?", ("A1010",))
+            date_str = cur.fetchone()[0]
+            # Should be ISO8601 with time component
+            assert "T" in date_str
+            assert "07:00" in date_str
+
+    def test_load_activities_indexed_by_type(self, sample_xer_single_project: Path) -> None:
+        """Should be able to efficiently query activities by type."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            # Query milestones
+            cur.execute("SELECT COUNT(*) FROM activities WHERE task_type = ?", ("TT_Mile",))
+            milestone_count = cur.fetchone()[0]
+            assert milestone_count == 2
+
+            # Query tasks
+            cur.execute("SELECT COUNT(*) FROM activities WHERE task_type = ?", ("TT_Task",))
+            task_count = cur.fetchone()[0]
+            assert task_count == 3
+
+    def test_load_critical_path_activities(self, sample_xer_single_project: Path) -> None:
+        """Should be able to query critical path activities via index."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            cur.execute("SELECT COUNT(*) FROM activities WHERE driving_path_flag = 1")
+            critical_count = cur.fetchone()[0]
+            # Activities A1000, A1010, A1030, A1040 are on critical path
+            assert critical_count == 4
+
+    def test_load_replaces_previous_data(self, sample_xer_single_project: Path) -> None:
+        """Loading a new file should replace previous data."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+
+        # Load first time
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            cur.execute("SELECT COUNT(*) FROM activities")
+            first_count = cur.fetchone()[0]
+
+        # Clear and load again
+        db.clear()
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            cur.execute("SELECT COUNT(*) FROM activities")
+            second_count = cur.fetchone()[0]
+
+        assert first_count == second_count
+
+
+class TestMultiProjectHandling:
+    """Integration tests for multi-project XER file handling."""
+
+    def test_load_selected_project_from_multi(self, sample_xer_multi_project: Path) -> None:
+        """Should load only the selected project from multi-project file."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_multi_project)
+
+        # Load only Project Alpha
+        load_parsed_data(parsed, project_id="1001")
+
+        with db.cursor() as cur:
+            cur.execute("SELECT proj_short_name FROM projects")
+            names = [row[0] for row in cur.fetchall()]
+            assert names == ["Project Alpha"]
+
+            cur.execute("SELECT COUNT(*) FROM activities WHERE proj_id = ?", ("1001",))
+            assert cur.fetchone()[0] == 1
+
+    def test_multi_project_list_available(self, sample_xer_multi_project: Path) -> None:
+        """Parser should report all available projects."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_multi_project)
+
+        assert len(parsed.projects) == 2
+        proj_ids = {p["proj_id"] for p in parsed.projects}
+        assert proj_ids == {"1001", "1002"}

tests/unit/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for XER MCP Server."""

tests/unit/test_db_queries.py

@@ -0,0 +1,111 @@
+"""Unit tests for database query functions."""
+
+from pathlib import Path
+
+import pytest
+
+from xer_mcp.db import db
+
+
+@pytest.fixture(autouse=True)
+def setup_db():
+    """Initialize and clear database for each test."""
+    db.initialize()
+    yield
+    db.clear()
+
+
+class TestActivityQueries:
+    """Tests for activity query functions."""
+
+    def test_query_activities_with_pagination(self, sample_xer_single_project: Path) -> None:
+        """Should return paginated activity results."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import query_activities
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        activities, total = query_activities(limit=2, offset=0)
+
+        assert len(activities) == 2
+        assert total == 5
+
+    def test_query_activities_filter_by_type(self, sample_xer_single_project: Path) -> None:
+        """Should filter activities by task type."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import query_activities
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        activities, total = query_activities(activity_type="TT_Mile")
+
+        assert total == 2
+        for act in activities:
+            assert act["task_type"] == "TT_Mile"
+
+    def test_query_activities_filter_by_date_range(self, sample_xer_single_project: Path) -> None:
+        """Should filter activities by date range."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import query_activities
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        # Filter to very narrow range
+        activities, total = query_activities(start_date="2026-01-01", end_date="2026-01-01")
+
+        # Only activities starting on 2026-01-01
+        for act in activities:
+            assert "2026-01-01" in act["target_start_date"]
+
+    def test_query_activities_filter_by_wbs(self, sample_xer_single_project: Path) -> None:
+        """Should filter activities by WBS ID."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import query_activities
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        activities, total = query_activities(wbs_id="102")
+
+        # WBS 102 has 2 activities
+        assert total == 2
+
+    def test_get_activity_by_id(self, sample_xer_single_project: Path) -> None:
+        """Should return single activity by ID."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import get_activity_by_id
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        activity = get_activity_by_id("2002")
+
+        assert activity is not None
+        assert activity["task_code"] == "A1010"
+
+    def test_get_activity_by_id_not_found(self, sample_xer_single_project: Path) -> None:
+        """Should return None for non-existent activity."""
+        from xer_mcp.db.loader import load_parsed_data
+        from xer_mcp.db.queries import get_activity_by_id
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        parsed = parser.parse(sample_xer_single_project)
+        load_parsed_data(parsed, project_id="1001")
+
+        activity = get_activity_by_id("nonexistent")
+
+        assert activity is None

tests/unit/test_parser.py

@@ -0,0 +1,146 @@
+"""Unit tests for XER parser."""
+
+from pathlib import Path
+
+import pytest
+
+
+class TestXerParser:
+    """Tests for the XER file parser."""
+
+    def test_parse_single_project_file(self, sample_xer_single_project: Path) -> None:
+        """Parser should extract project data from single-project XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        assert len(result.projects) == 1
+        assert result.projects[0]["proj_id"] == "1001"
+        assert result.projects[0]["proj_short_name"] == "Test Project"
+
+    def test_parse_multi_project_file(self, sample_xer_multi_project: Path) -> None:
+        """Parser should extract all projects from multi-project XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_multi_project)
+
+        assert len(result.projects) == 2
+        project_names = {p["proj_short_name"] for p in result.projects}
+        assert project_names == {"Project Alpha", "Project Beta"}
+
+    def test_parse_activities(self, sample_xer_single_project: Path) -> None:
+        """Parser should extract activities from XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # Single project fixture has 5 activities
+        assert len(result.tasks) == 5
+
+        # Check first milestone
+        milestone = next(t for t in result.tasks if t["task_code"] == "A1000")
+        assert milestone["task_name"] == "Project Start"
+        assert milestone["task_type"] == "TT_Mile"
+
+    def test_parse_relationships(self, sample_xer_single_project: Path) -> None:
+        """Parser should extract relationships from XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # Single project fixture has 5 relationships
+        assert len(result.taskpreds) == 5
+
+        # Check a FS relationship
+        fs_rel = next(r for r in result.taskpreds if r["pred_type"] == "PR_FS")
+        assert fs_rel["lag_hr_cnt"] == 0
+
+        # Check a SS relationship
+        ss_rel = next(r for r in result.taskpreds if r["pred_type"] == "PR_SS")
+        assert ss_rel["lag_hr_cnt"] == 40
+
+    def test_parse_wbs(self, sample_xer_single_project: Path) -> None:
+        """Parser should extract WBS hierarchy from XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # Single project fixture has 3 WBS elements
+        assert len(result.projwbs) == 3
+
+        # Check root WBS
+        root = next(w for w in result.projwbs if w["wbs_short_name"] == "ROOT")
+        assert root["parent_wbs_id"] is None or root["parent_wbs_id"] == ""
+
+    def test_parse_calendars(self, sample_xer_single_project: Path) -> None:
+        """Parser should extract calendars from XER file."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # Single project fixture has 1 calendar
+        assert len(result.calendars) == 1
+        cal = result.calendars[0]
+        assert cal["clndr_name"] == "Standard 5 Day"
+        assert cal["day_hr_cnt"] == 8
+
+    def test_parse_empty_project(self, sample_xer_empty: Path) -> None:
+        """Parser should handle XER file with no activities."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_empty)
+
+        assert len(result.projects) == 1
+        assert len(result.tasks) == 0
+        assert len(result.taskpreds) == 0
+
+    def test_parse_invalid_file_raises_error(self, invalid_xer_file: Path) -> None:
+        """Parser should raise ParseError for invalid XER content."""
+        from xer_mcp.errors import ParseError
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        with pytest.raises(ParseError):
+            parser.parse(invalid_xer_file)
+
+    def test_parse_nonexistent_file_raises_error(self, nonexistent_xer_path: Path) -> None:
+        """Parser should raise FileNotFoundError for missing file."""
+        from xer_mcp.errors import FileNotFoundError
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        with pytest.raises(FileNotFoundError):
+            parser.parse(nonexistent_xer_path)
+
+    def test_parse_dates_converted_to_iso8601(self, sample_xer_single_project: Path) -> None:
+        """Parser should convert XER dates to ISO8601 format."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # Check date conversion (XER: "2026-01-01 07:00" -> ISO: "2026-01-01T07:00:00")
+        task = next(t for t in result.tasks if t["task_code"] == "A1000")
+        assert "T" in task["target_start_date"]
+
+    def test_parse_driving_path_flag(self, sample_xer_single_project: Path) -> None:
+        """Parser should correctly parse driving_path_flag as boolean."""
+        from xer_mcp.parser.xer_parser import XerParser
+
+        parser = XerParser()
+        result = parser.parse(sample_xer_single_project)
+
+        # A1000 has driving_path_flag = Y
+        critical_task = next(t for t in result.tasks if t["task_code"] == "A1000")
+        assert critical_task["driving_path_flag"] is True
+
+        # A1020 has driving_path_flag = N
+        non_critical = next(t for t in result.tasks if t["task_code"] == "A1020")
+        assert non_critical["driving_path_flag"] is False

tests/unit/test_table_handlers.py

@@ -0,0 +1,192 @@
+"""Unit tests for XER table handlers."""
+
+
+class TestProjectHandler:
+    """Tests for PROJECT table handler."""
+
+    def test_parse_project_row(self) -> None:
+        """Handler should parse PROJECT row correctly."""
+        from xer_mcp.parser.table_handlers.project import ProjectHandler
+
+        handler = ProjectHandler()
+
+        # Minimal PROJECT fields
+        fields = [
+            "proj_id",
+            "proj_short_name",
+            "plan_start_date",
+            "plan_end_date",
+        ]
+        values = ["1001", "Test Project", "2026-01-01 00:00", "2026-06-30 00:00"]
+
+        result = handler.parse_row(fields, values)
+
+        assert result is not None
+        assert result["proj_id"] == "1001"
+        assert result["proj_short_name"] == "Test Project"
+        assert result["plan_start_date"] == "2026-01-01T00:00:00"
+        assert result["plan_end_date"] == "2026-06-30T00:00:00"
+
+    def test_table_name(self) -> None:
+        """Handler should report correct table name."""
+        from xer_mcp.parser.table_handlers.project import ProjectHandler
+
+        handler = ProjectHandler()
+        assert handler.table_name == "PROJECT"
+
+
+class TestTaskHandler:
+    """Tests for TASK table handler."""
+
+    def test_parse_task_row(self) -> None:
+        """Handler should parse TASK row correctly."""
+        from xer_mcp.parser.table_handlers.task import TaskHandler
+
+        handler = TaskHandler()
+
+        fields = [
+            "task_id",
+            "proj_id",
+            "wbs_id",
+            "task_code",
+            "task_name",
+            "task_type",
+            "status_code",
+            "target_start_date",
+            "target_end_date",
+            "total_float_hr_cnt",
+            "driving_path_flag",
+        ]
+        values = [
+            "2001",
+            "1001",
+            "100",
+            "A1000",
+            "Site Prep",
+            "TT_Task",
+            "TK_NotStart",
+            "2026-01-02 07:00",
+            "2026-01-08 15:00",
+            "0",
+            "Y",
+        ]
+
+        result = handler.parse_row(fields, values)
+
+        assert result is not None
+        assert result["task_id"] == "2001"
+        assert result["task_code"] == "A1000"
+        assert result["task_type"] == "TT_Task"
+        assert result["driving_path_flag"] is True
+        assert result["total_float_hr_cnt"] == 0.0
+
+    def test_table_name(self) -> None:
+        """Handler should report correct table name."""
+        from xer_mcp.parser.table_handlers.task import TaskHandler
+
+        handler = TaskHandler()
+        assert handler.table_name == "TASK"
+
+
+class TestTaskpredHandler:
+    """Tests for TASKPRED table handler."""
+
+    def test_parse_relationship_row(self) -> None:
+        """Handler should parse TASKPRED row correctly."""
+        from xer_mcp.parser.table_handlers.taskpred import TaskpredHandler
+
+        handler = TaskpredHandler()
+
+        fields = [
+            "task_pred_id",
+            "task_id",
+            "pred_task_id",
+            "proj_id",
+            "pred_proj_id",
+            "pred_type",
+            "lag_hr_cnt",
+        ]
+        values = ["3001", "2002", "2001", "1001", "1001", "PR_FS", "8"]
+
+        result = handler.parse_row(fields, values)
+
+        assert result is not None
+        assert result["task_pred_id"] == "3001"
+        assert result["task_id"] == "2002"
+        assert result["pred_task_id"] == "2001"
+        assert result["pred_type"] == "PR_FS"
+        assert result["lag_hr_cnt"] == 8.0
+
+    def test_table_name(self) -> None:
+        """Handler should report correct table name."""
+        from xer_mcp.parser.table_handlers.taskpred import TaskpredHandler
+
+        handler = TaskpredHandler()
+        assert handler.table_name == "TASKPRED"
+
+
+class TestProjwbsHandler:
+    """Tests for PROJWBS table handler."""
+
+    def test_parse_wbs_row(self) -> None:
+        """Handler should parse PROJWBS row correctly."""
+        from xer_mcp.parser.table_handlers.projwbs import ProjwbsHandler
+
+        handler = ProjwbsHandler()
+
+        fields = [
+            "wbs_id",
+            "proj_id",
+            "parent_wbs_id",
+            "wbs_short_name",
+            "wbs_name",
+        ]
+        values = ["100", "1001", "", "ROOT", "Project Root"]
+
+        result = handler.parse_row(fields, values)
+
+        assert result is not None
+        assert result["wbs_id"] == "100"
+        assert result["proj_id"] == "1001"
+        assert result["parent_wbs_id"] == ""
+        assert result["wbs_short_name"] == "ROOT"
+
+    def test_table_name(self) -> None:
+        """Handler should report correct table name."""
+        from xer_mcp.parser.table_handlers.projwbs import ProjwbsHandler
+
+        handler = ProjwbsHandler()
+        assert handler.table_name == "PROJWBS"
+
+
+class TestCalendarHandler:
+    """Tests for CALENDAR table handler."""
+
+    def test_parse_calendar_row(self) -> None:
+        """Handler should parse CALENDAR row correctly."""
+        from xer_mcp.parser.table_handlers.calendar import CalendarHandler
+
+        handler = CalendarHandler()
+
+        fields = [
+            "clndr_id",
+            "clndr_name",
+            "day_hr_cnt",
+            "week_hr_cnt",
+        ]
+        values = ["1", "Standard 5 Day", "8", "40"]
+
+        result = handler.parse_row(fields, values)
+
+        assert result is not None
+        assert result["clndr_id"] == "1"
+        assert result["clndr_name"] == "Standard 5 Day"
+        assert result["day_hr_cnt"] == 8.0
+        assert result["week_hr_cnt"] == 40.0
+
+    def test_table_name(self) -> None:
+        """Handler should report correct table name."""
+        from xer_mcp.parser.table_handlers.calendar import CalendarHandler
+
+        handler = CalendarHandler()
+        assert handler.table_name == "CALENDAR"

uv.lock

@@ -0,0 +1,601 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/42/9c391dd801d6cf0d561b5890549d4b27bafcc53b39c31a817e69d87c625b/cryptography-46.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:109d4ddfadf17e8e7779c39f9b18111a09efb969a301a31e987416a0191ed93a", size = 7225004, upload-time = "2025-10-15T23:16:52.239Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
+    { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
+    { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
+    { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
+    { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
+    { url = "https://files.pythonhosted.org/packages/96/92/8a6a9525893325fc057a01f654d7efc2c64b9de90413adcf605a85744ff4/cryptography-46.0.3-cp311-abi3-win32.whl", hash = "sha256:f260d0d41e9b4da1ed1e0f1ce571f97fe370b152ab18778e9e8f67d6af432018", size = 3055988, upload-time = "2025-10-15T23:17:14.65Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/bf/80fbf45253ea585a1e492a6a17efcb93467701fa79e71550a430c5e60df0/cryptography-46.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:a9a3008438615669153eb86b26b61e09993921ebdd75385ddd748702c5adfddb", size = 3514451, upload-time = "2025-10-15T23:17:16.142Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/af/9b302da4c87b0beb9db4e756386a7c6c5b8003cd0e742277888d352ae91d/cryptography-46.0.3-cp311-abi3-win_arm64.whl", hash = "sha256:5d7f93296ee28f68447397bf5198428c9aeeab45705a55d53a6343455dcb2c3c", size = 2928007, upload-time = "2025-10-15T23:17:18.04Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e2/a510aa736755bffa9d2f75029c229111a1d02f8ecd5de03078f4c18d91a3/cryptography-46.0.3-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:00a5e7e87938e5ff9ff5447ab086a5706a957137e6e433841e9d24f38a065217", size = 7158012, upload-time = "2025-10-15T23:17:19.982Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
+    { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
+    { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
+    { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/30/27654c1dbaf7e4a3531fa1fc77986d04aefa4d6d78259a62c9dc13d7ad36/cryptography-46.0.3-cp314-cp314t-win32.whl", hash = "sha256:8a6e050cb6164d3f830453754094c086ff2d0b2f3a897a1d9820f6139a1f0914", size = 3022339, upload-time = "2025-10-15T23:17:40.888Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/30/640f34ccd4d2a1bc88367b54b926b781b5a018d65f404d409aba76a84b1c/cryptography-46.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:760f83faa07f8b64e9c33fc963d790a2edb24efb479e3520c14a45741cd9b2db", size = 3494315, upload-time = "2025-10-15T23:17:42.769Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8b/88cc7e3bd0a8e7b861f26981f7b820e1f46aa9d26cc482d0feba0ecb4919/cryptography-46.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:516ea134e703e9fe26bcd1277a4b59ad30586ea90c365a87781d7887a646fe21", size = 2919331, upload-time = "2025-10-15T23:17:44.468Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/23/45fe7f376a7df8daf6da3556603b36f53475a99ce4faacb6ba2cf3d82021/cryptography-46.0.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:cb3d760a6117f621261d662bccc8ef5bc32ca673e037c83fbe565324f5c46936", size = 7218248, upload-time = "2025-10-15T23:17:46.294Z" },
+    { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
+    { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
+    { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/1c8331ddf91ca4730ab3086a0f1be19c65510a33b5a441cb334e7a2d2560/cryptography-46.0.3-cp38-abi3-win32.whl", hash = "sha256:6276eb85ef938dc035d59b87c8a7dc559a232f954962520137529d77b18ff1df", size = 3036695, upload-time = "2025-10-15T23:18:08.672Z" },
+    { url = "https://files.pythonhosted.org/packages/90/45/b0d691df20633eff80955a0fc7695ff9051ffce8b69741444bd9ed7bd0db/cryptography-46.0.3-cp38-abi3-win_amd64.whl", hash = "sha256:416260257577718c05135c55958b674000baef9a1c7d9e8f306ec60d71db850f", size = 3501720, upload-time = "2025-10-15T23:18:10.632Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "jsonschema-specifications" },
+    { name = "referencing" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.25.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "jsonschema" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "python-multipart" },
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/2d/649d80a0ecf6a1f82632ca44bec21c0461a9d9fc8934d38cb5b319f2db5e/mcp-1.25.0.tar.gz", hash = "sha256:56310361ebf0364e2d438e5b45f7668cbb124e158bb358333cd06e49e83a6802", size = 605387, upload-time = "2025-12-19T10:19:56.985Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e2/fc/6dc7659c2ae5ddf280477011f4213a74f806862856b796ef08f028e664bf/mcp-1.25.0-py3-none-any.whl", hash = "sha256:b37c38144a666add0862614cc79ec276e97d72aa8ca26d622818d4e278b9721a", size = 233076, upload-time = "2025-12-19T10:19:55.416Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "2.23"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyjwt"
+version = "2.10.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+    { name = "cryptography" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/96/804520d0850c7db98e5ccb70282e29208723f0964e88ffd9d0da2f52ea09/python_multipart-0.0.21.tar.gz", hash = "sha256:7137ebd4d3bbf70ea1622998f902b97a29434a9e8dc40eb203bbcf7c2a2cba92", size = 37196, upload-time = "2025-12-17T09:24:22.446Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/76/03af049af4dcee5d27442f71b6924f01f3efb5d2bd34f23fcd563f2cc5f5/python_multipart-0.0.21-py3-none-any.whl", hash = "sha256:cf7a6713e01c87aa35387f4774e812c4361150938d20d232800f75ffcf266090", size = 24541, upload-time = "2025-12-17T09:24:21.153Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" },
+    { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "rpds-py"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" },
+    { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" },
+    { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" },
+    { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" },
+    { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" },
+    { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" },
+    { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" },
+    { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" },
+    { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.14.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/08/52232a877978dd8f9cf2aeddce3e611b40a63287dfca29b6b8da791f5e8d/ruff-0.14.10.tar.gz", hash = "sha256:9a2e830f075d1a42cd28420d7809ace390832a490ed0966fe373ba288e77aaf4", size = 5859763, upload-time = "2025-12-18T19:28:57.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/01/933704d69f3f05ee16ef11406b78881733c186fe14b6a46b05cfcaf6d3b2/ruff-0.14.10-py3-none-linux_armv6l.whl", hash = "sha256:7a3ce585f2ade3e1f29ec1b92df13e3da262178df8c8bdf876f48fa0e8316c49", size = 13527080, upload-time = "2025-12-18T19:29:25.642Z" },
+    { url = "https://files.pythonhosted.org/packages/df/58/a0349197a7dfa603ffb7f5b0470391efa79ddc327c1e29c4851e85b09cc5/ruff-0.14.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:674f9be9372907f7257c51f1d4fc902cb7cf014b9980152b802794317941f08f", size = 13797320, upload-time = "2025-12-18T19:29:02.571Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/82/36be59f00a6082e38c23536df4e71cdbc6af8d7c707eade97fcad5c98235/ruff-0.14.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d85713d522348837ef9df8efca33ccb8bd6fcfc86a2cde3ccb4bc9d28a18003d", size = 12918434, upload-time = "2025-12-18T19:28:51.202Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/00/45c62a7f7e34da92a25804f813ebe05c88aa9e0c25e5cb5a7d23dd7450e3/ruff-0.14.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6987ebe0501ae4f4308d7d24e2d0fe3d7a98430f5adfd0f1fead050a740a3a77", size = 13371961, upload-time = "2025-12-18T19:29:04.991Z" },
+    { url = "https://files.pythonhosted.org/packages/40/31/a5906d60f0405f7e57045a70f2d57084a93ca7425f22e1d66904769d1628/ruff-0.14.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16a01dfb7b9e4eee556fbfd5392806b1b8550c9b4a9f6acd3dbe6812b193c70a", size = 13275629, upload-time = "2025-12-18T19:29:21.381Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/60/61c0087df21894cf9d928dc04bcd4fb10e8b2e8dca7b1a276ba2155b2002/ruff-0.14.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7165d31a925b7a294465fa81be8c12a0e9b60fb02bf177e79067c867e71f8b1f", size = 14029234, upload-time = "2025-12-18T19:29:00.132Z" },
+    { url = "https://files.pythonhosted.org/packages/44/84/77d911bee3b92348b6e5dab5a0c898d87084ea03ac5dc708f46d88407def/ruff-0.14.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c561695675b972effb0c0a45db233f2c816ff3da8dcfbe7dfc7eed625f218935", size = 15449890, upload-time = "2025-12-18T19:28:53.573Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/36/480206eaefa24a7ec321582dda580443a8f0671fdbf6b1c80e9c3e93a16a/ruff-0.14.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bb98fcbbc61725968893682fd4df8966a34611239c9fd07a1f6a07e7103d08e", size = 15123172, upload-time = "2025-12-18T19:29:23.453Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/68e414156015ba80cef5473d57919d27dfb62ec804b96180bafdeaf0e090/ruff-0.14.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f24b47993a9d8cb858429e97bdf8544c78029f09b520af615c1d261bf827001d", size = 14460260, upload-time = "2025-12-18T19:29:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/19/9e050c0dca8aba824d67cc0db69fb459c28d8cd3f6855b1405b3f29cc91d/ruff-0.14.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59aabd2e2c4fd614d2862e7939c34a532c04f1084476d6833dddef4afab87e9f", size = 14229978, upload-time = "2025-12-18T19:29:11.32Z" },
+    { url = "https://files.pythonhosted.org/packages/51/eb/e8dd1dd6e05b9e695aa9dd420f4577debdd0f87a5ff2fedda33c09e9be8c/ruff-0.14.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:213db2b2e44be8625002dbea33bb9c60c66ea2c07c084a00d55732689d697a7f", size = 14338036, upload-time = "2025-12-18T19:29:09.184Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/12/f3e3a505db7c19303b70af370d137795fcfec136d670d5de5391e295c134/ruff-0.14.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b914c40ab64865a17a9a5b67911d14df72346a634527240039eb3bd650e5979d", size = 13264051, upload-time = "2025-12-18T19:29:13.431Z" },
+    { url = "https://files.pythonhosted.org/packages/08/64/8c3a47eaccfef8ac20e0484e68e0772013eb85802f8a9f7603ca751eb166/ruff-0.14.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1484983559f026788e3a5c07c81ef7d1e97c1c78ed03041a18f75df104c45405", size = 13283998, upload-time = "2025-12-18T19:29:06.994Z" },
+    { url = "https://files.pythonhosted.org/packages/12/84/534a5506f4074e5cc0529e5cd96cfc01bb480e460c7edf5af70d2bcae55e/ruff-0.14.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c70427132db492d25f982fffc8d6c7535cc2fd2c83fc8888f05caaa248521e60", size = 13601891, upload-time = "2025-12-18T19:28:55.811Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1e/14c916087d8598917dbad9b2921d340f7884824ad6e9c55de948a93b106d/ruff-0.14.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5bcf45b681e9f1ee6445d317ce1fa9d6cba9a6049542d1c3d5b5958986be8830", size = 14336660, upload-time = "2025-12-18T19:29:16.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/1c/d7b67ab43f30013b47c12b42d1acd354c195351a3f7a1d67f59e54227ede/ruff-0.14.10-py3-none-win32.whl", hash = "sha256:104c49fc7ab73f3f3a758039adea978869a918f31b73280db175b43a2d9b51d6", size = 13196187, upload-time = "2025-12-18T19:29:19.006Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/9c/896c862e13886fae2af961bef3e6312db9ebc6adc2b156fe95e615dee8c1/ruff-0.14.10-py3-none-win_amd64.whl", hash = "sha256:466297bd73638c6bdf06485683e812db1c00c7ac96d4ddd0294a338c62fdc154", size = 14661283, upload-time = "2025-12-18T19:29:30.16Z" },
+    { url = "https://files.pythonhosted.org/packages/74/31/b0e29d572670dca3674eeee78e418f20bdf97fa8aa9ea71380885e175ca0/ruff-0.14.10-py3-none-win_arm64.whl", hash = "sha256:e51d046cf6dda98a4633b8a8a771451107413b0f07183b2bef03f075599e44e6", size = 13729839, upload-time = "2025-12-18T19:28:48.636Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/f5df66cb383efdbf4f2db23cabb27f51b1dcb737efaf8a558f6f1d195134/sse_starlette-3.1.2.tar.gz", hash = "sha256:55eff034207a83a0eb86de9a68099bd0157838f0b8b999a1b742005c71e33618", size = 26303, upload-time = "2025-12-31T08:02:20.023Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/95/8c4b76eec9ae574474e5d2997557cebf764bcd3586458956c30631ae08f4/sse_starlette-3.1.2-py3-none-any.whl", hash = "sha256:cd800dd349f4521b317b9391d3796fa97b71748a4da9b9e00aafab32dda375c8", size = 12484, upload-time = "2025-12-31T08:02:18.894Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.50.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.40.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" },
+]
+
+[[package]]
+name = "xer-mcp"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "mcp" },
+]
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "mcp", specifier = ">=1.0.0" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
+    { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.24.0" },
+    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.8.0" },
+]
+provides-extras = ["dev"]