Upload 14 files

Dockerfile

@@ -1,18 +1,23 @@
-FROM python:3.10
+FROM python:3.11-slim
 
-RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+RUN groupadd -g 1000 appuser && useradd -m -u 1000 -g 1000 appuser
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY dateutil /app/dateutil
+COPY app.py /app/app.py
 
-COPY --chown=user . /app
 ENV MCP_TRANSPORT=http
 ENV MCP_PORT=7860
 
 EXPOSE 7860
 
-CMD ["python", "dateutil/mcp_output/start_mcp.py"]
+USER appuser
+
+ENTRYPOINT ["python", "dateutil/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,72 @@
 ---
-title: Dateutil
-emoji: 🔥
-colorFrom: pink
-colorTo: yellow
+title: dateutil MCP Service
+emoji: 🔧
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# dateutil MCP Service
+
+This deployment packages `python-dateutil` as an MCP service using FastMCP.
+It supports local `stdio` mode and Docker/HTTP mode for HuggingFace Spaces.
+
+## Available MCP Tools
+
+- `health_check`
+- `parse_datetime`
+- `parse_iso_datetime`
+- `compute_relativedelta`
+- `generate_rrule_occurrences`
+- `resolve_timezone`
+- `calculate_easter`
+- `list_loaded_modules`
+
+## Local stdio usage
+
+```bash
+cd dateutil/mcp_output
+python start_mcp.py
+```
+
+Or explicitly:
+
+```bash
+MCP_TRANSPORT=stdio MCP_PORT=8000 python start_mcp.py
+```
+
+For local CLI / Claude Desktop style clients, use stdio transport.
+
+## HTTP client usage
+
+Run in HTTP mode:
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python dateutil/mcp_output/start_mcp.py
+```
+
+Then connect MCP clients to:
+
+- `http://localhost:7860/mcp`
+
+For HuggingFace Spaces, the public endpoint is:
+
+- `https://<your-space-host>/mcp`
+
+## Docker
+
+Build and run:
+
+```bash
+bash run_docker.sh
+```
+
+Or on PowerShell:
+
+```powershell
+./run_docker.ps1
+```
+
+The Docker entrypoint is `python dateutil/mcp_output/start_mcp.py`.

app.py

@@ -1,45 +1,63 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+
+from fastapi import FastAPI  # type: ignore[import-not-found]
+
+ROOT_DIR = Path(__file__).resolve().parent
+PLUGIN_DIR = (ROOT_DIR / "dateutil" / "mcp_output" / "mcp_plugin").resolve()
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "dateutil", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+app = FastAPI(title="dateutil MCP info app", version="1.0.0")
 
-app = FastAPI(
-    title="Dateutil MCP Service",
-    description="Auto-generated MCP service for dateutil",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def service_info() -> dict:
     return {
-        "service": "Dateutil MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "dateutil-mcp",
+        "description": "Supplementary info API for dateutil MCP deployment",
+        "mcp_entrypoint": "dateutil/mcp_output/start_mcp.py",
+        "transport_default": "stdio",
+        "http_endpoint": "/mcp when MCP_TRANSPORT=http",
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "dateutil MCP"}
+def health() -> dict:
+    return {"status": "healthy"}
+
 
 @app.get("/tools")
-def list_tools():
-    try:
-        from mcp_service import create_app
-        mcp_app = create_app()
-        tools = []
-        for tool_name, tool_func in mcp_app.tools.items():
-            tools.append({
-                "name": tool_name,
-                "description": tool_func.__doc__ or "No description available"
-            })
-        return {"tools": tools}
-    except Exception as e:
-        return {"error": f"Failed to load tools: {str(e)}"}
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+def tools() -> dict:
+    import importlib
+
+    service_module = importlib.import_module("mcp_service")
+    create_app = getattr(service_module, "create_app")
+    mcp = create_app()
+    raw_tools = getattr(mcp, "tools", None)
+
+    items: list[dict] = []
+    if isinstance(raw_tools, dict):
+        for key, tool_obj in raw_tools.items():
+            items.append(
+                {
+                    "name": getattr(tool_obj, "name", str(key)),
+                    "description": getattr(tool_obj, "description", ""),
+                }
+            )
+    elif isinstance(raw_tools, list):
+        for tool_obj in raw_tools:
+            items.append(
+                {
+                    "name": getattr(tool_obj, "name", "unknown"),
+                    "description": getattr(tool_obj, "description", ""),
+                }
+            )
+
+    return {"count": len(items), "tools": items}
+
+
+PORT = int(os.getenv("PORT", "7860"))

dateutil/mcp_output/README_MCP.md

@@ -1,129 +1,89 @@
-# dateutil MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This service wraps the `python-dateutil` library as an MCP (Model Context Protocol) service for robust date/time handling in LLM workflows.
-
-Main capabilities:
-- Parse flexible human-readable datetime strings
-- Parse strict ISO-8601 datetime strings
-- Perform calendar-aware arithmetic (`relativedelta`)
-- Generate recurring schedules (`rrule` / `rruleset`)
-- Handle time zones, DST ambiguity, and imaginary times
-- Provide utility helpers (today, default tz assignment, delta comparisons)
-- Compute Easter dates
-
-Repository analyzed: `https://github.com/dateutil/dateutil`
-
----
-
-## 2) Installation Method
-
-### Requirements
-- Python 3.x
-- `python-dateutil`
-- `six` (runtime dependency used by dateutil)
-
-### Install
-pip install python-dateutil
-
-If you are implementing this as an MCP (Model Context Protocol) server, also install your MCP runtime/framework (depends on your stack), then add `python-dateutil` to the same environment.
-
----
-
-## 3) Quick Start
-
-Typical service actions your MCP (Model Context Protocol) server can expose:
-
-- Parse free-form datetime:
-  - Input: `"next Friday 5pm"`
-  - Backend: `dateutil.parser.parse(...)`
-
-- Parse ISO datetime:
-  - Input: `"2026-03-12T10:30:00+00:00"`
-  - Backend: `dateutil.parser.isoparser`
-
-- Date arithmetic:
-  - Add one month, set weekday rules, etc.
-  - Backend: `dateutil.relativedelta.relativedelta`
-
-- Recurrence generation:
-  - Build schedules like “every Tuesday at 09:00”
-  - Backend: `dateutil.rrule`
-
-- Time zone normalization:
-  - Detect ambiguous/non-existent local times around DST transitions
-  - Backend: `dateutil.tz.datetime_ambiguous`, `datetime_exists`, `resolve_imaginary`
-
-- Utility checks:
-  - `within_delta`, `today`, `default_tzinfo`
-
----
-
-## 4) Available Tools and Endpoints List
-
-Recommended MCP (Model Context Protocol) service endpoint design:
-
-1. `datetime.parse`
-- Purpose: Parse natural-language or mixed-format datetime strings
-- Core module: `dateutil.parser._parser.parse`
-- Notes: Powerful but permissive; validate inputs for production workflows
-
-2. `datetime.parse_iso`
-- Purpose: Strict ISO-8601 parsing
-- Core module: `dateutil.parser.isoparser`
-- Notes: Prefer when deterministic format validation is required
-
-3. `datetime.add_relativedelta`
-- Purpose: Calendar-aware arithmetic (months/years/weekday semantics)
-- Core module: `dateutil.relativedelta.relativedelta`
-
-4. `datetime.recurrence.generate`
-- Purpose: Generate repeated datetime sequences
-- Core module: `dateutil.rrule.rrule`, `rruleset`, `rrulestr`
-- Notes: Supports RFC 5545-style recurrence logic
-
-5. `timezone.convert_or_resolve`
-- Purpose: Apply/convert time zones and handle DST edge cases
-- Core module: `dateutil.tz.tz*`, `datetime_exists`, `datetime_ambiguous`, `resolve_imaginary`, `enfold`
-
-6. `calendar.easter`
-- Purpose: Compute Easter date by year
-- Core module: `dateutil.easter.easter`
-
-7. `datetime.utils`
-- Purpose: Small helpers (`today`, `default_tzinfo`, `within_delta`)
-- Core module: `dateutil.utils`
-
----
-
-## 5) Common Issues and Notes
-
-- Ambiguous or non-existent local times:
-  - DST transitions can produce duplicate or invalid local timestamps.
-  - Use `datetime_ambiguous`, `datetime_exists`, and `resolve_imaginary`.
-
-- Parsing ambiguity:
-  - Free-form parsing may infer unintended day/month ordering.
-  - Prefer strict ISO endpoint for critical pipelines.
-
-- Time zone data differences:
-  - Platform behavior may vary (especially Windows-specific timezone handling via `tzwin`).
-
-- Performance:
-  - Large recurrence expansions can be expensive.
-  - Require range limits (`start`, `end`, `count`) in endpoint contracts.
-
-- Testing/dev dependencies:
-  - `pytest`, `hypothesis`, and Sphinx tooling are for tests/docs, not required at runtime.
-
----
-
-## 6) Reference Links / Documentation
-
-- Upstream repository: https://github.com/dateutil/dateutil
-- Official docs: https://dateutil.readthedocs.io/
-- PyPI package: https://pypi.org/project/python-dateutil/
-- RFC 5545 recurrence background: https://datatracker.ietf.org/doc/html/rfc5545
-
-If needed, I can also generate a production-ready `mcp_server.py` endpoint skeleton aligned to the tool list above.
+# dateutil MCP Plugin
+
+This MCP layer exposes key capabilities from `python-dateutil` for parsing, recurrence handling, timezone resolution, and calendar calculations.
+
+## Exposed Tools
+
+### 1) `health_check`
+- Parameters: none
+- Returns dependency health and adapter load state.
+- Example:
+  - Call: `health_check()`
+
+### 2) `parse_datetime`
+- Parameters:
+  - `value: str`
+  - `dayfirst: bool = False`
+  - `yearfirst: bool = False`
+- Parses free-form datetime strings.
+- Example:
+  - Call: `parse_datetime(value="2026-03-23 10:20", dayfirst=False, yearfirst=True)`
+
+### 3) `parse_iso_datetime`
+- Parameters:
+  - `value: str`
+- Parses strict ISO-8601 datetime text.
+- Example:
+  - Call: `parse_iso_datetime(value="2026-03-23T10:20:00+08:00")`
+
+### 4) `compute_relativedelta`
+- Parameters:
+  - `start: str`
+  - `end: str`
+- Computes calendar-aware delta between two date/time values.
+- Example:
+  - Call: `compute_relativedelta(start="2025-01-01", end="2026-03-23")`
+
+### 5) `generate_rrule_occurrences`
+- Parameters:
+  - `frequency: str` (`YEARLY|MONTHLY|WEEKLY|DAILY`)
+  - `dtstart: str`
+  - `count: int = 5`
+  - `interval: int = 1`
+- Generates recurrence instances using `dateutil.rrule`.
+- Example:
+  - Call: `generate_rrule_occurrences(frequency="WEEKLY", dtstart="2026-01-01", count=4, interval=1)`
+
+### 6) `resolve_timezone`
+- Parameters:
+  - `tz_name: str`
+- Resolves IANA timezone and reports current offset.
+- Example:
+  - Call: `resolve_timezone(tz_name="Asia/Shanghai")`
+
+### 7) `calculate_easter`
+- Parameters:
+  - `year: int`
+- Returns Easter Sunday date for a given year.
+- Example:
+  - Call: `calculate_easter(year=2027)`
+
+### 8) `list_loaded_modules`
+- Parameters: none
+- Lists adapter-loaded and failed modules.
+- Example:
+  - Call: `list_loaded_modules()`
+
+## Run Locally (stdio)
+
+From `dateutil/mcp_output/`:
+
+```bash
+python start_mcp.py
+```
+
+Or explicitly:
+
+```bash
+MCP_TRANSPORT=stdio MCP_PORT=8000 python start_mcp.py
+```
+
+## Run via HTTP Transport
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+The MCP endpoint is served by FastMCP at:
+
+- `http://localhost:7860/mcp`

dateutil/mcp_output/mcp_plugin/adapter.py

@@ -1,432 +1,208 @@
-import os
-import sys
+from __future__ import annotations
+
 import importlib
-from typing import Any, Dict, Optional, List
+import inspect
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
 
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = (CURRENT_DIR / ".." / ".." / "source").resolve()
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
 
 class Adapter:
-    """
-    Import-mode adapter for the dateutil repository implementation under source/src/dateutil.
-
-    This adapter attempts to import repository modules directly from the local source tree.
-    If import fails, methods provide graceful fallback responses with actionable guidance.
-    """
-
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._modules: Dict[str, Any] = {}
-        self._import_errors: Dict[str, str] = {}
-        self._initialize_imports()
-
-    # -------------------------------------------------------------------------
-    # Internal helpers
-    # -------------------------------------------------------------------------
-    def _result(
-        self,
-        status: str,
-        data: Optional[Any] = None,
-        message: str = "",
-        error: str = "",
-        meta: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        payload = {"status": status}
-        if message:
-            payload["message"] = message
-        if error:
-            payload["error"] = error
-        if data is not None:
-            payload["data"] = data
-        if meta is not None:
-            payload["meta"] = meta
-        return payload
-
-    def _initialize_imports(self) -> None:
-        module_names = [
-            "src.dateutil",
-            "src.dateutil.easter",
-            "src.dateutil.parser",
-            "src.dateutil.parser._parser",
-            "src.dateutil.parser.isoparser",
-            "src.dateutil.relativedelta",
-            "src.dateutil.rrule",
-            "src.dateutil.tz",
-            "src.dateutil.tz.tz",
-            "src.dateutil.tz.win",
-            "src.dateutil.tzwin",
-            "src.dateutil.utils",
-            "src.dateutil.zoneinfo",
-            "src.dateutil.zoneinfo.rebuild",
+    def __init__(self, module_names: list[str] | None = None) -> None:
+        self.module_names = module_names or [
+            "dateutil",
+            "dateutil.parser",
+            "dateutil.relativedelta",
+            "dateutil.rrule",
+            "dateutil.tz",
+            "dateutil.easter",
+            "dateutil.zoneinfo",
         ]
-        for mod_name in module_names:
+        self.loaded_modules: dict[str, ModuleType] = {}
+        self.failed_modules: dict[str, str] = {}
+        self.mode = "blackbox"
+        self._load_modules()
+
+    def _load_modules(self) -> None:
+        for module_name in self.module_names:
             try:
-                self._modules[mod_name] = importlib.import_module(mod_name)
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
             except Exception as exc:
-                self._import_errors[mod_name] = str(exc)
-
-    def _get_module(self, module_name: str) -> Dict[str, Any]:
-        mod = self._modules.get(module_name)
-        if mod is not None:
-            return self._result("success", data=mod)
-        err = self._import_errors.get(module_name, "Unknown import error.")
-        return self._result(
-            "fallback",
-            message=(
-                f"Module '{module_name}' is unavailable in import mode. "
-                "Verify repository source path and dependencies (e.g., six)."
-            ),
-            error=err,
-        )
-
-    def health_check(self) -> Dict[str, Any]:
-        """
-        Report adapter initialization and import state.
-
-        Returns:
-            dict: Unified status payload with loaded modules and import errors.
-        """
-        return self._result(
-            "success" if not self._import_errors else "partial",
-            data={
-                "mode": self.mode,
-                "loaded_modules": sorted(self._modules.keys()),
-                "failed_modules": self._import_errors,
-                "source_path": source_path,
-            },
-        )
-
-    # -------------------------------------------------------------------------
-    # dateutil.easter
-    # -------------------------------------------------------------------------
-    def call_easter(self, year: int, method: int = 3) -> Dict[str, Any]:
-        """
-        Compute Easter date for a given year.
-
-        Parameters:
-            year (int): Year for Easter calculation.
-            method (int): Calculation method from dateutil.easter constants.
-
-        Returns:
-            dict: status + computed date or fallback/error information.
-        """
-        mod_res = self._get_module("src.dateutil.easter")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "easter")
-            return self._result("success", data=fn(year, method))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to compute Easter: {exc}",
-                message="Validate year and method inputs.",
-            )
-
-    # -------------------------------------------------------------------------
-    # dateutil.parser
-    # -------------------------------------------------------------------------
-    def call_parse(self, timestr: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Parse a date/time string using dateutil parser.
-
-        Parameters:
-            timestr (str): Input date/time text.
-            **kwargs: Additional parser keyword arguments.
-
-        Returns:
-            dict: status + parsed datetime or error.
-        """
-        mod_res = self._get_module("src.dateutil.parser")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "parse")
-            return self._result("success", data=fn(timestr, **kwargs))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to parse datetime string: {exc}",
-                message="Check input format and parser keyword arguments.",
-            )
-
-    def create_parserinfo(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create parserinfo instance from parser internals.
-
-        Parameters:
-            *args: Positional arguments for parserinfo.
-            **kwargs: Keyword arguments for parserinfo.
-
-        Returns:
-            dict: status + parserinfo instance or error.
-        """
-        mod_res = self._get_module("src.dateutil.parser._parser")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            cls = getattr(mod_res["data"], "parserinfo")
-            return self._result("success", data=cls(*args, **kwargs))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to create parserinfo: {exc}",
-                message="Review parserinfo constructor arguments.",
-            )
-
-    def create_isoparser(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create an ISO parser instance.
-
-        Parameters:
-            *args: Positional constructor args.
-            **kwargs: Keyword constructor args.
-
-        Returns:
-            dict: status + isoparser instance or error.
-        """
-        mod_res = self._get_module("src.dateutil.parser.isoparser")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            cls = getattr(mod_res["data"], "isoparser")
-            return self._result("success", data=cls(*args, **kwargs))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to create isoparser: {exc}",
-                message="Check isoparser constructor parameters.",
-            )
-
-    def call_isoparse(self, dt_str: str) -> Dict[str, Any]:
-        """
-        Parse ISO-8601 datetime string.
-
-        Parameters:
-            dt_str (str): ISO datetime text.
-
-        Returns:
-            dict: status + parsed datetime or error.
-        """
-        mod_res = self._get_module("src.dateutil.parser")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "isoparse")
-            return self._result("success", data=fn(dt_str))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to parse ISO datetime: {exc}",
-                message="Ensure the input follows ISO-8601 format.",
-            )
-
-    # -------------------------------------------------------------------------
-    # dateutil.relativedelta
-    # -------------------------------------------------------------------------
-    def create_relativedelta(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create relativedelta instance.
-
-        Parameters:
-            *args: Positional arguments.
-            **kwargs: Keyword arguments.
-
-        Returns:
-            dict: status + relativedelta instance or error.
-        """
-        mod_res = self._get_module("src.dateutil.relativedelta")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            cls = getattr(mod_res["data"], "relativedelta")
-            return self._result("success", data=cls(*args, **kwargs))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to create relativedelta: {exc}",
-                message="Check relativedelta arguments.",
-            )
-
-    # -------------------------------------------------------------------------
-    # dateutil.rrule
-    # -------------------------------------------------------------------------
-    def create_rrule(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.rrule")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            cls = getattr(mod_res["data"], "rrule")
-            return self._result("success", data=cls(*args, **kwargs))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to create rrule: {exc}")
-
-    def create_rruleset(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.rrule")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            cls = getattr(mod_res["data"], "rruleset")
-            return self._result("success", data=cls(*args, **kwargs))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to create rruleset: {exc}")
-
-    def call_rrulestr(self, s: str, **kwargs: Any) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.rrule")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "rrulestr")
-            return self._result("success", data=fn(s, **kwargs))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to parse RRULE string: {exc}")
-
-    # -------------------------------------------------------------------------
-    # dateutil.tz
-    # -------------------------------------------------------------------------
-    def call_gettz(self, name: Optional[str] = None) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.tz")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "gettz")
-            return self._result("success", data=fn(name))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to resolve timezone: {exc}")
-
-    def call_datetime_exists(self, dt: Any, tz: Optional[Any] = None) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.tz")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "datetime_exists")
-            return self._result("success", data=fn(dt, tz))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to check datetime existence: {exc}")
-
-    def call_datetime_ambiguous(self, dt: Any, tz: Optional[Any] = None) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.tz")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "datetime_ambiguous")
-            return self._result("success", data=fn(dt, tz))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to check datetime ambiguity: {exc}")
-
-    def call_resolve_imaginary(self, dt: Any) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.tz")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "resolve_imaginary")
-            return self._result("success", data=fn(dt))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to resolve imaginary time: {exc}")
-
-    # -------------------------------------------------------------------------
-    # dateutil.utils
-    # -------------------------------------------------------------------------
-    def call_today(self, tzinfo: Optional[Any] = None) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.utils")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "today")
-            return self._result("success", data=fn(tzinfo))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to compute today(): {exc}")
-
-    def call_within_delta(self, dt1: Any, dt2: Any, delta: Any) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.utils")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "within_delta")
-            return self._result("success", data=fn(dt1, dt2, delta))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to evaluate within_delta: {exc}")
-
-    # -------------------------------------------------------------------------
-    # dateutil.zoneinfo
-    # -------------------------------------------------------------------------
-    def call_get_zonefile_instance(self) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.zoneinfo")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "get_zonefile_instance")
-            return self._result("success", data=fn())
-        except Exception as exc:
-            return self._result("error", error=f"Failed to get zonefile instance: {exc}")
-
-    def call_gettz_zoneinfo(self, name: str) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.zoneinfo")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "gettz")
-            return self._result("success", data=fn(name))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to load zoneinfo timezone: {exc}")
-
-    def call_rebuild_zoneinfo(self, filename: Optional[str] = None) -> Dict[str, Any]:
-        mod_res = self._get_module("src.dateutil.zoneinfo.rebuild")
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            fn = getattr(mod_res["data"], "rebuild")
-            if filename is None:
-                return self._result("success", data=fn())
-            return self._result("success", data=fn(filename))
-        except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Failed to rebuild zoneinfo data: {exc}",
-                message="Provide a valid zoneinfo tarball path or run with default configuration.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Discovery helpers
-    # -------------------------------------------------------------------------
-    def list_available_modules(self) -> Dict[str, Any]:
-        """
-        List imported and failed modules for quick adapter introspection.
-
-        Returns:
-            dict: status with module availability details.
-        """
-        return self._result(
-            "success",
-            data={
-                "available": sorted(self._modules.keys()),
-                "failed": self._import_errors,
-            },
-        )
-
-    def list_module_attributes(self, module_name: str, public_only: bool = True) -> Dict[str, Any]:
-        """
-        List attributes for an imported module.
-
-        Parameters:
-            module_name (str): Fully-qualified module name.
-            public_only (bool): If True, omit private names starting with underscore.
-
-        Returns:
-            dict: status with attribute names or fallback/error details.
-        """
-        mod_res = self._get_module(module_name)
-        if mod_res["status"] != "success":
-            return mod_res
-        try:
-            names: List[str] = dir(mod_res["data"])
-            if public_only:
-                names = [n for n in names if not n.startswith("_")]
-            return self._result("success", data=sorted(names))
-        except Exception as exc:
-            return self._result("error", error=f"Failed to inspect module attributes: {exc}")
+                self.failed_modules[module_name] = str(exc)
+
+        self.mode = "active" if self.loaded_modules else "blackbox"
+
+    def health(self) -> dict[str, Any]:
+        status = "ok" if self.loaded_modules else "fallback"
+        return {
+            "status": status,
+            "mode": self.mode,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+            "loaded_modules": sorted(self.loaded_modules.keys()),
+            "failed_modules": self.failed_modules,
+        }
+
+    def list_modules(self) -> dict[str, Any]:
+        status = "ok" if self.loaded_modules else "fallback"
+        return {
+            "status": status,
+            "mode": self.mode,
+            "loaded": sorted(self.loaded_modules.keys()),
+            "failed": self.failed_modules,
+        }
+
+    def list_symbols(self, module_name: str, public_only: bool = True) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            if module_name in self.failed_modules:
+                return {
+                    "status": "error",
+                    "module": module_name,
+                    "error": self.failed_modules[module_name],
+                }
+            return {
+                "status": "error",
+                "module": module_name,
+                "error": "Module not loaded",
+            }
+
+        try:
+            symbols = []
+            for name in dir(module):
+                if public_only and name.startswith("_"):
+                    continue
+                value = getattr(module, name)
+                if inspect.ismodule(value):
+                    kind = "module"
+                elif inspect.isclass(value):
+                    kind = "class"
+                elif inspect.isfunction(value) or inspect.isbuiltin(value):
+                    kind = "function"
+                else:
+                    kind = type(value).__name__
+                symbols.append({"name": name, "kind": kind})
+
+            return {
+                "status": "ok",
+                "module": module_name,
+                "count": len(symbols),
+                "symbols": symbols,
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "module": module_name,
+                "error": str(exc),
+            }
+
+    def call_function(
+        self,
+        module_name: str,
+        function_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": "Module not loaded",
+            }
+
+        try:
+            function_obj = getattr(module, function_name)
+        except AttributeError:
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": "Function not found",
+            }
+
+        if not callable(function_obj):
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": "Target is not callable",
+            }
+
+        try:
+            final_args = args or []
+            final_kwargs = kwargs or {}
+            result = function_obj(*final_args, **final_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": result,
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": str(exc),
+            }
+
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": "Module not loaded",
+            }
+
+        try:
+            class_obj = getattr(module, class_name)
+        except AttributeError:
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": "Class not found",
+            }
+
+        if not inspect.isclass(class_obj):
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": "Target is not a class",
+            }
+
+        try:
+            final_args = args or []
+            final_kwargs = kwargs or {}
+            instance = class_obj(*final_args, **final_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__,
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": str(exc),
+            }

dateutil/mcp_output/mcp_plugin/main.py

@@ -1,13 +1,6 @@
-"""
-MCP Service Auto-Wrapper - Auto-generated
-"""
 from mcp_service import create_app
 
-def main():
-    """Main entry point"""
-    app = create_app()
-    return app
-
+# Local stdio entry point only (Claude Desktop / CLI), not for web or Docker deployment.
 if __name__ == "__main__":
-    app = main()
-    app.run()
+    app = create_app()
+    app.run()

dateutil/mcp_output/mcp_plugin/mcp_service.py

@@ -1,242 +1,278 @@
-import os
-import sys
-from datetime import datetime, date
-from typing import List, Optional, Dict, Any
+from __future__ import annotations
 
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
+import datetime as dt
+import sys
+from pathlib import Path
+from typing import Any
 
 from fastmcp import FastMCP
-from dateutil import easter
-from dateutil.parser import parse as dt_parse
-from dateutil.parser import isoparse
-from dateutil.relativedelta import relativedelta
-from dateutil.rrule import rrule, rrulestr, YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY
-from dateutil.tz import gettz, UTC
-
-
-mcp = FastMCP("dateutil_service")
-
-
-_FREQ_MAP = {
-    "YEARLY": YEARLY,
-    "MONTHLY": MONTHLY,
-    "WEEKLY": WEEKLY,
-    "DAILY": DAILY,
-    "HOURLY": HOURLY,
-    "MINUTELY": MINUTELY,
-    "SECONDLY": SECONDLY,
-}
-
-
-def _safe_result(value: Any) -> Dict[str, Any]:
-    return {"success": True, "result": value, "error": None}
-
 
-def _safe_error(exc: Exception) -> Dict[str, Any]:
-    return {"success": False, "result": None, "error": str(exc)}
-
-
-@mcp.tool(name="parse_datetime", description="Parse a general datetime string into ISO format.")
-def parse_datetime(
-    text: str,
-    dayfirst: bool = False,
-    yearfirst: bool = False,
-    default_iso: Optional[str] = None
-) -> Dict[str, Any]:
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = (CURRENT_DIR / ".." / ".." / "source").resolve()
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
+
+try:
+    import dateutil  # type: ignore
+except Exception:
+    dateutil = None
+
+try:
+    from dateutil.parser import parse as dateutil_parse  # type: ignore
+except Exception:
+    dateutil_parse = None
+
+try:
+    from dateutil.parser import isoparse as dateutil_isoparse  # type: ignore
+except Exception:
+    dateutil_isoparse = None
+
+try:
+    from dateutil.relativedelta import relativedelta  # type: ignore
+except Exception:
+    relativedelta = None
+
+try:
+    from dateutil.rrule import DAILY, MONTHLY, WEEKLY, YEARLY, rrule  # type: ignore
+except Exception:
+    DAILY = None
+    MONTHLY = None
+    WEEKLY = None
+    YEARLY = None
+    rrule = None
+
+try:
+    from dateutil.tz import gettz  # type: ignore
+except Exception:
+    gettz = None
+
+try:
+    from dateutil.easter import easter  # type: ignore
+except Exception:
+    easter = None
+
+try:
+    from adapter import Adapter
+except Exception:
+    Adapter = None
+
+mcp = FastMCP("dateutil-mcp-service")
+adapter = Adapter() if Adapter is not None else None
+
+
+def _ok(result: Any) -> dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
+
+
+def _err(message: str) -> dict[str, Any]:
+    return {"success": False, "result": None, "error": message}
+
+
+def _parse_datetime_value(value: str) -> dt.datetime:
+    if dateutil_parse is None:
+        raise RuntimeError("dateutil.parser.parse is unavailable")
+    return dateutil_parse(value)
+
+
+@mcp.tool(name="health_check", description="Report availability of dateutil and MCP dependencies")
+def health_check() -> dict[str, Any]:
+    """Return dependency and adapter health state."""
+    deps = {
+        "dateutil": dateutil is not None,
+        "dateutil_parse": dateutil_parse is not None,
+        "dateutil_isoparse": dateutil_isoparse is not None,
+        "relativedelta": relativedelta is not None,
+        "rrule": rrule is not None,
+        "gettz": gettz is not None,
+        "easter": easter is not None,
+        "adapter": adapter is not None,
+    }
+
+    result = {
+        "dependencies": deps,
+        "adapter": adapter.health() if adapter is not None else {"status": "fallback", "mode": "blackbox"},
+    }
+    return _ok(result)
+
+
+@mcp.tool(name="parse_datetime", description="Parse free-form datetime text with dateutil.parser")
+def parse_datetime(value: str, dayfirst: bool = False, yearfirst: bool = False) -> dict[str, Any]:
     """
-    Parse a datetime string using dateutil.parser.parse.
+    Parse a free-form date/time string.
 
     Parameters:
-    - text: Input datetime text to parse.
-    - dayfirst: Whether to interpret ambiguous dates as day-first.
-    - yearfirst: Whether to interpret ambiguous dates as year-first.
-    - default_iso: Optional ISO datetime used as default values for missing parts.
-
-    Returns:
-    - Dictionary with success/result/error.
+    - value: Input datetime string.
+    - dayfirst: Interpret ambiguous dates as day-first.
+    - yearfirst: Interpret ambiguous dates as year-first.
     """
+    if dateutil_parse is None:
+        return _err("dateutil.parser.parse is unavailable")
+
     try:
-        default_dt = None
-        if default_iso:
-            default_dt = datetime.fromisoformat(default_iso)
-        parsed = dt_parse(text, dayfirst=dayfirst, yearfirst=yearfirst, default=default_dt)
-        return _safe_result(parsed.isoformat())
+        parsed = dateutil_parse(value, dayfirst=dayfirst, yearfirst=yearfirst)
+        return _ok({"input": value, "iso": parsed.isoformat()})
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
 
 
-@mcp.tool(name="parse_iso_datetime", description="Parse an ISO-8601 datetime string.")
-def parse_iso_datetime(text: str) -> Dict[str, Any]:
+@mcp.tool(name="parse_iso_datetime", description="Parse ISO-8601 datetime string")
+def parse_iso_datetime(value: str) -> dict[str, Any]:
     """
-    Parse an ISO-8601 datetime string using dateutil.parser.isoparse.
+    Parse an ISO-8601 datetime string.
 
     Parameters:
-    - text: ISO datetime text.
-
-    Returns:
-    - Dictionary with success/result/error.
+    - value: ISO-8601 datetime text.
     """
+    if dateutil_isoparse is None:
+        return _err("dateutil.parser.isoparse is unavailable")
+
     try:
-        parsed = isoparse(text)
-        return _safe_result(parsed.isoformat())
+        parsed = dateutil_isoparse(value)
+        return _ok({"input": value, "iso": parsed.isoformat()})
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
 
 
-@mcp.tool(name="compute_easter", description="Compute Easter date for a given year.")
-def compute_easter(year: int, method: int = 3) -> Dict[str, Any]:
+@mcp.tool(name="compute_relativedelta", description="Compute calendar-aware delta between two datetimes")
+def compute_relativedelta(start: str, end: str) -> dict[str, Any]:
     """
-    Compute Easter date using dateutil.easter.easter.
+    Compute relativedelta between two datetime strings.
 
     Parameters:
-    - year: Target year.
-    - method: Easter algorithm (1=Julian, 2=Orthodox, 3=Western).
-
-    Returns:
-    - Dictionary with success/result/error.
+    - start: Start datetime string.
+    - end: End datetime string.
     """
-    try:
-        easter_date = easter.easter(year, method=method)
-        return _safe_result(easter_date.isoformat())
-    except Exception as exc:
-        return _safe_error(exc)
-
-
-@mcp.tool(name="add_relativedelta", description="Apply relative date/time offsets to a datetime.")
-def add_relativedelta(
-    base_iso: str,
-    years: int = 0,
-    months: int = 0,
-    weeks: int = 0,
-    days: int = 0,
-    hours: int = 0,
-    minutes: int = 0,
-    seconds: int = 0
-) -> Dict[str, Any]:
-    """
-    Apply relativedelta offsets to a base datetime.
-
-    Parameters:
-    - base_iso: Base datetime in ISO format.
-    - years, months, weeks, days, hours, minutes, seconds: Relative offsets.
+    if relativedelta is None:
+        return _err("dateutil.relativedelta.relativedelta is unavailable")
 
-    Returns:
-    - Dictionary with success/result/error.
-    """
     try:
-        base_dt = datetime.fromisoformat(base_iso)
-        delta = relativedelta(
-            years=years,
-            months=months,
-            weeks=weeks,
-            days=days,
-            hours=hours,
-            minutes=minutes,
-            seconds=seconds,
+        start_dt = _parse_datetime_value(start)
+        end_dt = _parse_datetime_value(end)
+        delta = relativedelta(end_dt, start_dt)
+        return _ok(
+            {
+                "start": start_dt.isoformat(),
+                "end": end_dt.isoformat(),
+                "years": delta.years,
+                "months": delta.months,
+                "days": delta.days,
+                "hours": delta.hours,
+                "minutes": delta.minutes,
+                "seconds": delta.seconds,
+                "microseconds": delta.microseconds,
+            }
         )
-        out = base_dt + delta
-        return _safe_result(out.isoformat())
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
 
 
-@mcp.tool(name="generate_rrule", description="Generate recurrence instances from rrule parameters.")
-def generate_rrule(
-    dtstart_iso: str,
-    freq: str,
-    count: int = 10,
-    interval: int = 1
-) -> Dict[str, Any]:
+@mcp.tool(name="generate_rrule_occurrences", description="Generate recurring datetimes from an rrule")
+def generate_rrule_occurrences(
+    frequency: str,
+    dtstart: str,
+    count: int = 5,
+    interval: int = 1,
+) -> dict[str, Any]:
     """
-    Generate recurrence datetimes using dateutil.rrule.rrule.
+    Generate recurring occurrences.
 
     Parameters:
-    - dtstart_iso: Start datetime in ISO format.
-    - freq: Frequency name: YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, SECONDLY.
-    - count: Number of occurrences to produce.
-    - interval: Frequency interval.
-
-    Returns:
-    - Dictionary with success/result/error.
+    - frequency: One of YEARLY, MONTHLY, WEEKLY, DAILY.
+    - dtstart: Start datetime string.
+    - count: Number of occurrences to generate.
+    - interval: Interval for recurrence frequency.
     """
+    if rrule is None:
+        return _err("dateutil.rrule.rrule is unavailable")
+
+    freq_lookup = {
+        "YEARLY": YEARLY,
+        "MONTHLY": MONTHLY,
+        "WEEKLY": WEEKLY,
+        "DAILY": DAILY,
+    }
+
+    normalized = frequency.upper().strip()
+    if normalized not in freq_lookup or freq_lookup[normalized] is None:
+        return _err("Invalid frequency. Use YEARLY, MONTHLY, WEEKLY, or DAILY")
+
+    if count < 1:
+        return _err("count must be >= 1")
+    if interval < 1:
+        return _err("interval must be >= 1")
+
     try:
-        freq_key = freq.upper().strip()
-        if freq_key not in _FREQ_MAP:
-            raise ValueError("Invalid freq value.")
-        dtstart = datetime.fromisoformat(dtstart_iso)
-        rule = rrule(_FREQ_MAP[freq_key], dtstart=dtstart, count=count, interval=interval)
-        items = [item.isoformat() for item in rule]
-        return _safe_result(items)
+        start_dt = _parse_datetime_value(dtstart)
+        rule = rrule(freq_lookup[normalized], dtstart=start_dt, count=count, interval=interval)
+        occurrences = [item.isoformat() for item in rule]
+        return _ok(
+            {
+                "frequency": normalized,
+                "dtstart": start_dt.isoformat(),
+                "count": count,
+                "interval": interval,
+                "occurrences": occurrences,
+            }
+        )
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
 
 
-@mcp.tool(name="expand_rrule_string", description="Expand an iCalendar RRULE string into occurrences.")
-def expand_rrule_string(
-    rule_text: str,
-    dtstart_iso: Optional[str] = None,
-    limit: int = 20
-) -> Dict[str, Any]:
+@mcp.tool(name="resolve_timezone", description="Resolve timezone by IANA name using dateutil.tz.gettz")
+def resolve_timezone(tz_name: str) -> dict[str, Any]:
     """
-    Expand occurrences from an RRULE string using dateutil.rrule.rrulestr.
+    Resolve timezone information.
 
     Parameters:
-    - rule_text: RRULE text (e.g., 'FREQ=DAILY;COUNT=5').
-    - dtstart_iso: Optional ISO datetime start.
-    - limit: Maximum number of occurrences returned.
-
-    Returns:
-    - Dictionary with success/result/error.
+    - tz_name: IANA timezone name, e.g. 'Asia/Shanghai'.
     """
+    if gettz is None:
+        return _err("dateutil.tz.gettz is unavailable")
+
     try:
-        dtstart = datetime.fromisoformat(dtstart_iso) if dtstart_iso else None
-        rule = rrulestr(rule_text, dtstart=dtstart)
-        items: List[str] = []
-        for i, item in enumerate(rule):
-            if i >= limit:
-                break
-            items.append(item.isoformat())
-        return _safe_result(items)
+        tzinfo = gettz(tz_name)
+        if tzinfo is None:
+            return _err(f"Timezone not found: {tz_name}")
+
+        now_utc = dt.datetime.now(dt.timezone.utc)
+        local_time = now_utc.astimezone(tzinfo)
+        offset = local_time.utcoffset()
+        return _ok(
+            {
+                "timezone": tz_name,
+                "resolved": True,
+                "current_time": local_time.isoformat(),
+                "utc_offset_seconds": int(offset.total_seconds()) if offset is not None else None,
+            }
+        )
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
 
 
-@mcp.tool(name="convert_timezone", description="Convert datetime from one timezone to another.")
-def convert_timezone(
-    dt_iso: str,
-    from_tz_name: str,
-    to_tz_name: str
-) -> Dict[str, Any]:
+@mcp.tool(name="calculate_easter", description="Calculate Easter Sunday date for a given year")
+def calculate_easter(year: int) -> dict[str, Any]:
     """
-    Convert datetime between timezones using dateutil.tz.gettz.
+    Calculate Easter Sunday date.
 
     Parameters:
-    - dt_iso: Input datetime in ISO format.
-    - from_tz_name: Source timezone name (e.g., 'UTC', 'America/New_York').
-    - to_tz_name: Target timezone name.
-
-    Returns:
-    - Dictionary with success/result/error.
+    - year: Gregorian year.
     """
+    if easter is None:
+        return _err("dateutil.easter.easter is unavailable")
+
     try:
-        dt = datetime.fromisoformat(dt_iso)
-        from_tz = UTC if from_tz_name.upper() == "UTC" else gettz(from_tz_name)
-        to_tz = UTC if to_tz_name.upper() == "UTC" else gettz(to_tz_name)
-        if from_tz is None or to_tz is None:
-            raise ValueError("Invalid timezone name.")
-        if dt.tzinfo is None:
-            dt = dt.replace(tzinfo=from_tz)
-        else:
-            dt = dt.astimezone(from_tz)
-        converted = dt.astimezone(to_tz)
-        return _safe_result(converted.isoformat())
+        result_date = easter(year)
+        return _ok({"year": year, "easter": result_date.isoformat()})
     except Exception as exc:
-        return _safe_error(exc)
+        return _err(str(exc))
+
+
+@mcp.tool(name="list_loaded_modules", description="List adapter module loading status")
+def list_loaded_modules() -> dict[str, Any]:
+    """List loaded/failed modules reported by adapter."""
+    if adapter is None:
+        return _err("Adapter unavailable")
+    return _ok(adapter.list_modules())
 
 
 def create_app() -> FastMCP:
@@ -244,4 +280,4 @@ def create_app() -> FastMCP:
 
 
 if __name__ == "__main__":
-    mcp.run()
+    mcp.run()

dateutil/mcp_output/requirements.txt

@@ -1,8 +1,3 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-six >= 1.6
-package_dir=
-=src
-packages = find:
+python-dateutil
+six

dateutil/mcp_output/start_mcp.py

@@ -1,30 +1,33 @@
+from __future__ import annotations
 
-"""
-MCP Service Startup Entry
-"""
-import sys
 import os
+import sys
+from pathlib import Path
 
-project_root = os.path.dirname(os.path.abspath(__file__))
-mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
-if mcp_plugin_dir not in sys.path:
-    sys.path.insert(0, mcp_plugin_dir)
+CURRENT_DIR = Path(__file__).resolve().parent
+PLUGIN_DIR = (CURRENT_DIR / "mcp_plugin").resolve()
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
 from mcp_service import create_app
 
-def main():
-    """Start FastMCP service"""
+
+def main() -> None:
+    transport = os.getenv("MCP_TRANSPORT", "stdio").strip().lower()
+    port = int(os.getenv("MCP_PORT", "8000"))
+
     app = create_app()
-    # Use environment variable to configure port, default 8000
-    port = int(os.environ.get("MCP_PORT", "8000"))
-    
-    # Choose transport mode based on environment variable
-    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
+    if transport == "stdio":
+        app.run(transport="stdio")
+        return
+
     if transport == "http":
         app.run(transport="http", host="0.0.0.0", port=port)
-    else:
-        # Default to STDIO mode
-        app.run()
+        return
+
+    raise ValueError("Unsupported MCP_TRANSPORT. Use 'stdio' or 'http'.")
+
 
 if __name__ == "__main__":
     main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "dateutil",
-  "port": 7951,
-  "timestamp": 1773283013
-}
+{"port": 7860}

requirements.txt

@@ -1,6 +1,5 @@
 fastmcp
+python-dateutil
+six
 fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-six >= 1.6
-dateutil
+uvicorn

run_docker.ps1

@@ -1,26 +1,8 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "dateutil" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7951/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "dateutil-mcp" }
-$mcpDir = Join-Path $env:USERPROFILE ".cursor"
-$mcpPath = Join-Path $mcpDir "mcp.json"
-if (!(Test-Path $mcpDir)) { New-Item -ItemType Directory -Path $mcpDir | Out-Null }
-$config = @{}
-if (Test-Path $mcpPath) {
-  try { $config = Get-Content $mcpPath -Raw | ConvertFrom-Json } catch { $config = @{} }
-}
-$serversOrdered = [ordered]@{}
-if ($config -and ($config.PSObject.Properties.Name -contains "mcpServers") -and $config.mcpServers) {
-  $existing = $config.mcpServers
-  if ($existing -is [pscustomobject]) {
-    foreach ($p in $existing.PSObject.Properties) { if ($p.Name -ne $entryName) { $serversOrdered[$p.Name] = $p.Value } }
-  } elseif ($existing -is [System.Collections.IDictionary]) {
-    foreach ($k in $existing.Keys) { if ($k -ne $entryName) { $serversOrdered[$k] = $existing[$k] } }
-  }
-}
-$serversOrdered[$entryName] = @{ url = $entryUrl }
-$config = @{ mcpServers = $serversOrdered }
-$config | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpPath -Encoding UTF8
+
+$portConfig = Get-Content -Raw -Path "port.json" | ConvertFrom-Json
+$port = $portConfig.port
+$imageName = "dateutil-mcp"
+
 docker build -t $imageName .
-docker run --rm -p 7951:7860 $imageName
+docker run --rm -p "${port}:${port}" -e MCP_TRANSPORT=http -e MCP_PORT=$port $imageName

run_docker.sh

@@ -1,75 +1,8 @@
 #!/usr/bin/env bash
 set -euo pipefail
-cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-mcp_entry_name="${MCP_ENTRY_NAME:-dateutil}"
-mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7951/mcp}"
-mcp_dir="${HOME}/.cursor"
-mcp_path="${mcp_dir}/mcp.json"
-mkdir -p "${mcp_dir}"
-if command -v python3 >/dev/null 2>&1; then
-python3 - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
-import json, os, sys
-path, name, url = sys.argv[1:4]
-cfg = {"mcpServers": {}}
-if os.path.exists(path):
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-    except Exception:
-        cfg = {"mcpServers": {}}
-if not isinstance(cfg, dict):
-    cfg = {"mcpServers": {}}
-servers = cfg.get("mcpServers")
-if not isinstance(servers, dict):
-    servers = {}
-ordered = {}
-for k, v in servers.items():
-    if k != name:
-        ordered[k] = v
-ordered[name] = {"url": url}
-cfg = {"mcpServers": ordered}
-with open(path, "w", encoding="utf-8") as f:
-    json.dump(cfg, f, indent=2, ensure_ascii=False)
-PY
-elif command -v python >/dev/null 2>&1; then
-python - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
-import json, os, sys
-path, name, url = sys.argv[1:4]
-cfg = {"mcpServers": {}}
-if os.path.exists(path):
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-    except Exception:
-        cfg = {"mcpServers": {}}
-if not isinstance(cfg, dict):
-    cfg = {"mcpServers": {}}
-servers = cfg.get("mcpServers")
-if not isinstance(servers, dict):
-    servers = {}
-ordered = {}
-for k, v in servers.items():
-    if k != name:
-        ordered[k] = v
-ordered[name] = {"url": url}
-cfg = {"mcpServers": ordered}
-with open(path, "w", encoding="utf-8") as f:
-    json.dump(cfg, f, indent=2, ensure_ascii=False)
-PY
-elif command -v jq >/dev/null 2>&1; then
-  name="${mcp_entry_name}"; url="${mcp_entry_url}"
-  if [ -f "${mcp_path}" ]; then
-    tmp="$(mktemp)"
-    jq --arg name "$name" --arg url "$url" '
-      .mcpServers = (.mcpServers // {})
-      | .mcpServers as $s
-      | ($s | with_entries(select(.key != $name))) as $base
-      | .mcpServers = ($base + {($name): {"url": $url}})
-    ' "${mcp_path}" > "${tmp}" && mv "${tmp}" "${mcp_path}"
-  else
-    printf '{ "mcpServers": { "%s": { "url": "%s" } } }
-' "$name" "$url" > "${mcp_path}"
-  fi
-fi
-docker build -t dateutil-mcp .
-docker run --rm -p 7951:7860 dateutil-mcp
+
+PORT=$(python3 -c "import json; print(json.load(open('port.json'))['port'])")
+IMAGE_NAME="dateutil-mcp"
+
+docker build -t "${IMAGE_NAME}" .
+docker run --rm -p "${PORT}:${PORT}" -e MCP_TRANSPORT=http -e MCP_PORT="${PORT}" "${IMAGE_NAME}"