tylor-mcp 1.0.0

package/server/tools/tests/test_personas.py

@@ -0,0 +1,52 @@
+"""
+Tests for Story 3.1: persona definition files
+Run: pytest server/tools/tests/test_personas.py -v
+"""
+from pathlib import Path
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+PERSONAS_DIR = PLUGIN_DIR / "server" / "personas"
+
+EXPECTED_PERSONAS = {
+    "code_agent.md": {"ecc/web", "ecc/data", "ecc/pipeline"},
+    "analyst.md": {"ecc/web", "ecc/data", "ecc/diagrams"},
+    "ceo.md": {"ecc/presentation", "ecc/web"},
+    "cto.md": {"ecc/diagrams", "ecc/pipeline"},
+}
+
+
+def _read_persona(filename: str) -> str:
+    return (PERSONAS_DIR / filename).read_text()
+
+
+def test_required_persona_files_exist():
+    for filename in EXPECTED_PERSONAS:
+        assert (PERSONAS_DIR / filename).exists(), f"Missing persona {filename}"
+
+
+def test_each_persona_has_required_sections():
+    for filename in EXPECTED_PERSONAS:
+        text = _read_persona(filename)
+        assert "# " in text
+        assert "## Role Description" in text
+        assert "## Communication Style" in text
+        assert "## ECC Tool Categories" in text
+
+
+def test_each_persona_declares_expected_ecc_categories():
+    for filename, expected_categories in EXPECTED_PERSONAS.items():
+        text = _read_persona(filename)
+        for category in expected_categories:
+            assert f"- `{category}`" in text, f"{filename} missing {category}"
+
+
+def test_each_persona_has_no_unexpected_ecc_categories():
+    allowed = set().union(*EXPECTED_PERSONAS.values())
+    for filename in EXPECTED_PERSONAS:
+        text = _read_persona(filename)
+        declared = {
+            line.strip().removeprefix("- `").removesuffix("`")
+            for line in text.splitlines()
+            if line.strip().startswith("- `ecc/")
+        }
+        assert declared <= allowed

package/server/tools/tests/test_recall_memory.py

@@ -0,0 +1,55 @@
+"""
+Tests for Story 2.5: recall_memory tool.
+Run: pytest server/tools/tests/test_recall_memory.py -v
+"""
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PLUGIN_DIR))
+
+from mcp.server.fastmcp.exceptions import ToolError
+from server.tools.tylor import recall_memory
+
+
+def test_recall_memory_calls_search_memory_with_top_k():
+    mock_client = MagicMock()
+    mock_client.search_memory.return_value = [{"id": "doc1"}]
+
+    with patch("server.tools.tylor._get_memory_client", return_value=mock_client):
+        result = recall_memory(thread_id="t1", query="find relevant facts", top_k=3)
+
+    mock_client.search_memory.assert_called_once_with(
+        thread_id="t1",
+        query="find relevant facts",
+        k=3,
+        type=None,
+    )
+    assert result == {"results": [{"id": "doc1"}]}
+
+
+def test_recall_memory_returns_empty_list_when_no_results():
+    mock_client = MagicMock()
+    mock_client.search_memory.return_value = []
+
+    with patch("server.tools.tylor._get_memory_client", return_value=mock_client):
+        result = recall_memory(thread_id="t1", query="missing facts")
+
+    assert result == {"results": []}
+
+
+def test_recall_memory_raises_on_empty_query():
+    with pytest.raises(ToolError, match="Query must not be empty"):
+        recall_memory(thread_id="t1", query="   ")
+
+
+def test_recall_memory_propagates_opensearch_errors():
+    mock_client = MagicMock()
+    mock_client.search_memory.side_effect = ToolError("search failed")
+
+    with patch("server.tools.tylor._get_memory_client", return_value=mock_client):
+        with pytest.raises(ToolError, match="search failed"):
+            recall_memory(thread_id="t1", query="search")

package/server/tools/tests/test_registry_client.py

@@ -0,0 +1,308 @@
+"""
+Tests for Story 4.2: two-tier manifest and skill registry client.
+Run: pytest server/tools/tests/test_registry_client.py -v
+"""
+import json
+import subprocess
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+
+
+def _write_registry(path: Path, skills: list[dict]) -> None:
+    path.write_text(
+        json.dumps({"version": "1.0", "skills": skills}, indent=2),
+        encoding="utf-8",
+    )
+
+
+def test_list_registry_returns_lightweight_skill_index(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "BMad story workflows",
+                "keywords": ["story", "review"],
+                "tool_count": 2,
+                "installed_date": "2026-05-13",
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+                "schemas": [{"name": "too-heavy"}],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path):
+        result = registry_mod.list_registry()
+
+    assert result == {
+        "skills": [
+            {
+                "name": "bmad",
+                "trigger_description": "BMad story workflows",
+                "keywords": ["story", "review"],
+                "tool_count": 2,
+            }
+        ]
+    }
+    assert "schemas" not in result["skills"][0]
+    assert "module" not in result["skills"][0]
+    assert "tools" not in result["skills"][0]
+
+
+def test_load_skill_tools_loads_registry_backed_group_without_restart(tmp_path):
+    from server.tools import registry as registry_mod
+    from server.tools._mcp import mcp
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "BMad story workflows",
+                "keywords": ["story"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path):
+        result = registry_mod.load_skill_tools("bmad")
+
+    assert result == {
+        "tool_group": "bmad",
+        "status": "loaded",
+        "tools": ["web_fetch", "web_scrape"],
+    }
+    tool_names = {tool.name for tool in __import__("asyncio").run(mcp.list_tools())}
+    assert {"web_fetch", "web_scrape"} <= tool_names
+
+
+def test_startup_manifest_is_tier1_only_and_lists_under_100ms():
+    code = """
+import asyncio, json, time
+import server.main
+from server.tools._mcp import mcp
+start = time.perf_counter()
+tools = asyncio.run(mcp.list_tools())
+elapsed_ms = (time.perf_counter() - start) * 1000
+print(json.dumps({"elapsed_ms": elapsed_ms, "tools": sorted(t.name for t in tools)}))
+"""
+    completed = subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=PLUGIN_DIR,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    payload = json.loads(completed.stdout)
+
+    tier2_tools = {
+        "web_scrape",
+        "web_fetch",
+        "dataset_manager",
+        "data_clean",
+        "data_transform",
+        "build_pptx",
+        "build_doc",
+        "diagram_gen",
+        "flowchart_gen",
+        "pipeline_builder",
+        "pipeline_run",
+    }
+    assert payload["elapsed_ms"] < 100
+    assert tier2_tools.isdisjoint(payload["tools"])
+
+
+def test_detect_registry_skill_match_surfaces_agent101_suggestion(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD or draft requirements.",
+                "keywords": ["prd", "requirements"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path):
+        result = registry_mod.detect_registry_skill("let's draft a PRD for this idea")
+
+    assert result == {
+        "matched": True,
+        "skill": "bmad",
+        "action": "suggest",
+        "message": "You have BMAD in agent101 — want me to use it?",
+        "thread_persistence": True,
+    }
+
+
+def test_auto_load_matching_registry_skill_loads_tools(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD.",
+                "keywords": ["prd"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path):
+        result = registry_mod.detect_registry_skill(
+            "let's draft a PRD for this idea",
+            auto_load=True,
+        )
+
+    assert result["matched"] is True
+    assert result["action"] == "loaded"
+    assert result["skill"] == "bmad"
+    assert result["loaded"]["tools"] == ["web_fetch", "web_scrape"]
+    assert result["thread_persistence"] is True
+
+
+def test_auto_load_matching_registry_skill_without_tools_falls_back_to_suggestion(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD.",
+                "keywords": ["prd"],
+                "tool_count": 1,
+                "source_path": "/local/skills/bmad",
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path), patch(
+        "server.tools.registry.importlib.import_module"
+    ) as import_module:
+        result = registry_mod.detect_registry_skill(
+            "let's draft a PRD for this idea",
+            auto_load=True,
+        )
+
+    assert result == {
+        "matched": True,
+        "skill": "bmad",
+        "action": "suggest",
+        "message": "You have BMAD in agent101 — want me to use it?",
+        "thread_persistence": True,
+    }
+    import_module.assert_not_called()
+
+
+def test_non_matching_registry_skill_does_not_load_schemas(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD.",
+                "keywords": ["prd"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path), patch(
+        "server.tools.registry.importlib.import_module"
+    ) as import_module:
+        result = registry_mod.detect_registry_skill("show my active threads", auto_load=True)
+
+    assert result == {"matched": False, "action": "none"}
+    import_module.assert_not_called()
+
+
+def test_generic_trigger_words_do_not_match_registry_skill(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD.",
+                "keywords": ["prd"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path), patch(
+        "server.tools.registry.importlib.import_module"
+    ) as import_module:
+        result = registry_mod.detect_registry_skill(
+            "create a new thread for billing",
+            auto_load=True,
+        )
+
+    assert result == {"matched": False, "action": "none"}
+    import_module.assert_not_called()
+
+
+def test_explicit_native_slash_skill_is_not_thread_persistent(tmp_path):
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "bmad",
+                "trigger_description": "Use when user wants to create a PRD.",
+                "keywords": ["prd"],
+                "tool_count": 2,
+                "module": "server.tools.ecc.web",
+                "tools": ["web_fetch", "web_scrape"],
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path), patch(
+        "server.tools.registry.importlib.import_module"
+    ) as import_module:
+        result = registry_mod.detect_registry_skill("/bmad create a PRD")
+
+    assert result == {
+        "matched": True,
+        "skill": "bmad",
+        "action": "claude_native",
+        "thread_persistence": False,
+    }
+    import_module.assert_not_called()

package/server/tools/tests/test_router.py

@@ -0,0 +1,263 @@
+"""
+Tests for Story 2.6: Model Router 3-Tier Fallback
+Run: pytest server/tools/tests/test_router.py -v
+"""
+from pathlib import Path
+import sys
+from unittest.mock import patch
+
+import pytest
+from mcp.shared.exceptions import McpError
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PLUGIN_DIR))
+
+
+class FakeMessages:
+    def __init__(self, result=None, error=None):
+        self.result = result
+        self.error = error
+        self.calls = []
+
+    def create(self, **kwargs):
+        self.calls.append(kwargs)
+        if self.error:
+            raise self.error
+        return self.result
+
+
+class FakeClient:
+    def __init__(self, result=None, error=None):
+        self.messages = FakeMessages(result=result, error=error)
+
+
+class AnthropicStyleError(Exception):
+    def __init__(self, error_type: str, message: str = "boom"):
+        super().__init__(message)
+        self.type = error_type
+
+
+def test_primary_success_returns_response_as_is_without_platform_route():
+    from server.tools.router import ModelRouter
+
+    response = object()
+    primary = FakeClient(result=response)
+    platform = FakeClient(result={"unused": True})
+    router = ModelRouter(primary_client=primary, platform_client=platform)
+
+    request = {
+        "model": "claude-sonnet-4-6",
+        "max_tokens": 128,
+        "messages": [{"role": "user", "content": "hello"}],
+    }
+
+    assert router.create_message(**request) is response
+    assert primary.messages.calls == [request]
+    assert platform.messages.calls == []
+
+
+def test_rate_limit_error_retries_identical_request_via_platform_route():
+    from server.tools.router import ModelRouter
+
+    primary_error = AnthropicStyleError("rate_limit_error", "primary overflow")
+    primary = FakeClient(error=primary_error)
+    platform_response = {"content": "fallback response"}
+    platform = FakeClient(result=platform_response)
+    router = ModelRouter(primary_client=primary, platform_client=platform)
+
+    request = {
+        "model": "claude-sonnet-4-6",
+        "max_tokens": 128,
+        "messages": [{"role": "user", "content": "same request"}],
+        "temperature": 0,
+    }
+
+    assert router.create_message(**request) == platform_response
+    assert primary.messages.calls == [request]
+    assert platform.messages.calls == [request]
+
+
+def test_context_length_exceeded_does_not_use_platform_route():
+    from server.tools.router import ModelRouter
+
+    primary_error = AnthropicStyleError("context_length_exceeded", "too long")
+    primary = FakeClient(error=primary_error)
+    platform = FakeClient(result={"unused": True})
+    router = ModelRouter(primary_client=primary, platform_client=platform)
+
+    with pytest.raises(AnthropicStyleError, match="too long"):
+        router.create_message(model="claude-sonnet-4-6", max_tokens=128, messages=[])
+
+    assert platform.messages.calls == []
+
+
+def test_non_overflow_primary_error_does_not_use_platform_route():
+    from server.tools.router import ModelRouter
+
+    primary_error = AnthropicStyleError("authentication_error", "bad key")
+    primary = FakeClient(error=primary_error)
+    platform = FakeClient(result={"unused": True})
+    router = ModelRouter(primary_client=primary, platform_client=platform)
+
+    with pytest.raises(AnthropicStyleError, match="bad key"):
+        router.create_message(model="claude-sonnet-4-6", max_tokens=128, messages=[])
+
+    assert platform.messages.calls == []
+
+
+def test_exhausted_routes_raise_mcp_internal_error():
+    from server.tools.router import ModelRouter
+
+    primary = FakeClient(error=AnthropicStyleError("rate_limit_error", "primary limit"))
+    platform = FakeClient(error=RuntimeError("platform unavailable"))
+    router = ModelRouter(primary_client=primary, platform_client=platform)
+
+    with pytest.raises(McpError) as exc_info:
+        router.create_message(model="claude-sonnet-4-6", max_tokens=128, messages=[])
+
+    error = exc_info.value.error
+    assert error.code == -32603
+    assert error.message == "All model routes exhausted"
+
+
+def test_overflow_with_null_platform_key_raises_mcp_error_immediately(monkeypatch):
+    import server.config as server_config
+    from server.tools.router import ModelRouter
+
+    monkeypatch.setattr(server_config, "config", {"platform_key": None})
+
+    primary = FakeClient(error=AnthropicStyleError("rate_limit_error", "rate limited"))
+    router = ModelRouter(primary_client=primary, platform_client=None)
+
+    with pytest.raises(McpError) as exc_info:
+        router.create_message(model="claude-sonnet-4-6", max_tokens=128, messages=[])
+
+    error = exc_info.value.error
+    assert error.code == -32603
+    assert error.message == "All model routes exhausted"
+
+
+def test_platform_client_cached_after_first_overflow(monkeypatch):
+    import server.config as server_config
+    from server.tools.router import ModelRouter
+
+    monkeypatch.setattr(
+        server_config,
+        "config",
+        {
+            "platform_key": "test-key",
+            "platform_base_url": "https://aws-external-anthropic.us-east-1.api.aws",
+            "platform_workspace_id": None,
+            "bedrock_region": "us-east-1",
+        },
+    )
+
+    platform_response = {"content": "fallback"}
+    primary = FakeClient(error=AnthropicStyleError("rate_limit_error", "rate limited"))
+    router = ModelRouter(primary_client=primary, platform_client=None)
+
+    with patch("anthropic.Anthropic") as anthropic_cls:
+        mock_client = anthropic_cls.return_value
+        mock_client.messages.create.return_value = platform_response
+        router.create_message(model="claude-sonnet-4-6", max_tokens=128, messages=[])
+
+    assert router.platform_client is mock_client
+    assert anthropic_cls.call_count == 1
+
+
+def test_platform_base_url_uses_regional_aws_endpoint():
+    from server.tools.router import build_platform_base_url
+
+    assert (
+        build_platform_base_url("us-east-1")
+        == "https://aws-external-anthropic.us-east-1.api.aws"
+    )
+
+
+def test_build_platform_client_uses_key_base_url_and_workspace_header(monkeypatch):
+    import server.config as server_config
+    from server.tools.router import build_platform_client
+
+    monkeypatch.setattr(
+        server_config,
+        "config",
+        {
+            "platform_key": "test-key",
+            "platform_base_url": "https://aws-external-anthropic.us-east-1.api.aws",
+            "platform_workspace_id": "wrkspc_test",
+            "bedrock_region": "us-east-1",
+        },
+    )
+
+    with patch("anthropic.Anthropic") as anthropic_cls:
+        build_platform_client()
+
+    anthropic_cls.assert_called_once_with(
+        api_key="test-key",
+        base_url="https://aws-external-anthropic.us-east-1.api.aws",
+        default_headers={"anthropic-workspace-id": "wrkspc_test"},
+    )
+
+
+def test_build_platform_client_no_workspace_id_sends_no_header(monkeypatch):
+    import server.config as server_config
+    from server.tools.router import build_platform_client
+
+    monkeypatch.setattr(
+        server_config,
+        "config",
+        {
+            "platform_key": "test-key",
+            "platform_base_url": "https://aws-external-anthropic.us-east-1.api.aws",
+            "platform_workspace_id": None,
+            "bedrock_region": "us-east-1",
+        },
+    )
+
+    with patch("anthropic.Anthropic") as anthropic_cls:
+        build_platform_client()
+
+    anthropic_cls.assert_called_once_with(
+        api_key="test-key",
+        base_url="https://aws-external-anthropic.us-east-1.api.aws",
+        default_headers=None,
+    )
+
+
+def test_build_platform_client_raises_when_platform_key_missing(monkeypatch):
+    import server.config as server_config
+    from server.tools.router import build_platform_client
+
+    monkeypatch.setattr(server_config, "config", {"platform_key": None})
+
+    with pytest.raises(RuntimeError, match="ANTHROPIC_PLATFORM_AWS_API_KEY not configured"):
+        build_platform_client()
+
+
+def test_error_type_string_matching_fallback():
+    from server.tools.router import _error_type
+
+    class PlainError(Exception):
+        pass
+
+    assert _error_type(PlainError("rate_limit_error in response")) == "rate_limit_error"
+
+
+def test_error_type_returns_empty_string_for_unknown_error():
+    from server.tools.router import _error_type
+
+    class PlainError(Exception):
+        pass
+
+    assert _error_type(PlainError("something completely different")) == ""
+
+
+def test_create_message_convenience_wrapper_success():
+    from server.tools.router import create_message
+
+    response = object()
+    primary = FakeClient(result=response)
+    request = {"model": "claude-sonnet-4-6", "max_tokens": 128, "messages": []}
+
+    assert create_message(primary, **request) is response
+    assert primary.messages.calls == [request]