tylor-mcp 1.0.0

package/server/tools/tests/test_skill_installer.py

@@ -0,0 +1,174 @@
+"""
+Tests for Story 4.3: /add-skill command and auto-generated registry entries.
+Run: pytest server/tools/tests/test_skill_installer.py -v
+"""
+import json
+from pathlib import Path
+
+import pytest
+from mcp.shared.exceptions import McpError
+from mcp.types import INVALID_PARAMS
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+
+
+def _write_skill_package(root: Path, name: str = "bmad") -> Path:
+    package = root / name
+    package.mkdir(parents=True)
+    (package / "SKILL.md").write_text(
+        "---\n"
+        f"name: {name}\n"
+        "description: Use when user wants to create a PRD, review stories, or run BMAD workflows.\n"
+        "---\n\n"
+        f"# /{name}\n\n"
+        "Use when user wants to create a PRD, review stories, or run BMAD workflows.\n\n"
+        "Call `load_skill_tools(\"bmad\")` when this trigger matches.\n",
+        encoding="utf-8",
+    )
+    (package / "notes.md").write_text("extra file", encoding="utf-8")
+    return package
+
+
+def _read_registry(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def test_install_skill_copies_package_and_appends_generated_registry_entry(tmp_path):
+    from server.tools.skill_installer import install_skill
+
+    source = _write_skill_package(tmp_path / "source")
+    skills_dir = tmp_path / "skills"
+    registry_path = tmp_path / "registry.json"
+    registry_path.write_text('{"version":"1.0","skills":[]}', encoding="utf-8")
+
+    result = install_skill(
+        source_path=source,
+        skills_dir=skills_dir,
+        registry_path=registry_path,
+    )
+
+    target = skills_dir / "bmad"
+    assert result["name"] == "bmad"
+    assert result["installed_to"] == str(target)
+    assert (target / "SKILL.md").exists()
+    assert (target / "notes.md").read_text(encoding="utf-8") == "extra file"
+
+    registry = _read_registry(registry_path)
+    [entry] = registry["skills"]
+    assert entry["name"] == "bmad"
+    assert entry["trigger"]
+    assert entry["trigger_description"] == entry["trigger"]
+    assert {"prd", "review", "stories", "bmad", "workflows"} <= set(entry["keywords"])
+    assert entry["tool_count"] == 1
+    assert entry["source_path"] == str(source)
+    assert entry["installed_date"]
+
+
+def test_install_skill_requires_skill_markdown(tmp_path):
+    from server.tools.skill_installer import install_skill
+
+    source = tmp_path / "empty-skill"
+    source.mkdir()
+
+    with pytest.raises(McpError) as excinfo:
+        install_skill(
+            source_path=source,
+            skills_dir=tmp_path / "skills",
+            registry_path=tmp_path / "registry.json",
+        )
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert "SKILL.md not found" in excinfo.value.error.message
+
+
+def test_install_skill_duplicate_requires_overwrite_confirmation(tmp_path):
+    from server.tools.skill_installer import install_skill
+
+    source = _write_skill_package(tmp_path / "source")
+    skills_dir = tmp_path / "skills"
+    registry_path = tmp_path / "registry.json"
+    registry_path.write_text(
+        json.dumps(
+            {
+                "version": "1.0",
+                "skills": [
+                    {
+                        "name": "bmad",
+                        "trigger": "existing",
+                        "trigger_description": "existing",
+                        "keywords": ["existing"],
+                        "tool_count": 1,
+                        "installed_date": "2026-05-12",
+                        "source_path": "/old",
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(McpError) as excinfo:
+        install_skill(
+            source_path=source,
+            skills_dir=skills_dir,
+            registry_path=registry_path,
+        )
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert "already exists" in excinfo.value.error.message
+    assert "overwrite=True" in excinfo.value.error.message
+
+    result = install_skill(
+        source_path=source,
+        skills_dir=skills_dir,
+        registry_path=registry_path,
+        overwrite=True,
+    )
+    assert result["status"] == "installed"
+    registry = _read_registry(registry_path)
+    assert len(registry["skills"]) == 1
+    assert registry["skills"][0]["source_path"] == str(source)
+
+
+def test_install_skill_preserves_module_and_tools_from_frontmatter(tmp_path):
+    from server.tools.skill_installer import install_skill
+
+    package = tmp_path / "source"
+    package.mkdir(parents=True)
+    (package / "SKILL.md").write_text(
+        "---\n"
+        "name: bmad\n"
+        "description: Use when user wants to create a PRD.\n"
+        "module: server.tools.ecc.web\n"
+        "tools: [\"web_fetch\", \"web_scrape\"]\n"
+        "---\n\n"
+        "# /bmad\n\n"
+        "Call `load_skill_tools(\"bmad\")` when this trigger matches.\n",
+        encoding="utf-8",
+    )
+    skills_dir = tmp_path / "skills"
+    registry_path = tmp_path / "registry.json"
+    registry_path.write_text('{"version":"1.0","skills":[]}', encoding="utf-8")
+
+    result = install_skill(
+        source_path=package,
+        skills_dir=skills_dir,
+        registry_path=registry_path,
+    )
+
+    registry = _read_registry(registry_path)
+    entry = registry["skills"][0]
+    assert entry["module"] == "server.tools.ecc.web"
+    assert entry["tools"] == ["web_fetch", "web_scrape"]
+    assert result["name"] == "bmad"
+
+
+def test_add_skill_slash_command_file_exists_and_mentions_installer():
+    path = PLUGIN_DIR / "skills" / "add-skill" / "SKILL.md"
+    assert path.exists()
+    text = path.read_text(encoding="utf-8")
+    assert "name: add-skill" in text
+    assert "/add-skill" in text
+    assert "server.tools.skill_installer" in text
+    assert "overwrite" in text.lower()
+    assert "registry.json" in text

package/server/tools/tests/test_switch_thread.py

@@ -0,0 +1,163 @@
+"""
+Tests for Story 2.4: switch_thread tool and DynamoDB atomic write helper.
+Run: pytest server/tools/tests/test_switch_thread.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.storage.dynamo import DynamoClient
+from server.tools.tylor import switch_thread
+
+
+def make_client(mock_table=None):
+    with patch("boto3.Session") as mock_session_cls:
+        mock_session = MagicMock()
+        mock_session_cls.return_value = mock_session
+        resource = MagicMock()
+        mock_session.resource.return_value = resource
+        table = mock_table or MagicMock()
+        resource.Table.return_value = table
+        client = DynamoClient(table_name="agent101", user_id="testuser")
+        client.table = table
+        return client, table
+
+
+def test_switch_thread_tool_calls_dynamo_switch():
+    mock_db = MagicMock()
+    with patch("server.tools.tylor._get_db", return_value=mock_db):
+        mock_db.switch_thread.return_value = {
+            "thread_id": "t2",
+            "status": "switched",
+            "switched_at": "2026-05-12T10:00:00Z",
+        }
+
+        result = switch_thread("t2")
+
+    mock_db.switch_thread.assert_called_once_with("t2")
+    assert result["thread_id"] == "t2"
+
+
+def test_switch_thread_includes_code_index_header_when_available():
+    mock_db = MagicMock()
+    mock_db.switch_thread.return_value = {
+        "thread_id": "t2",
+        "status": "switched",
+        "switched_at": "2026-05-12T10:00:00Z",
+        "name": "Frontend",
+    }
+    mock_db.get_thread_meta.return_value = {"Name": "Frontend"}
+
+    with patch("server.tools.tylor._get_db", return_value=mock_db), patch(
+        "server.tools.hooks.build_code_index_header",
+        return_value="[Frontend Thread — Code Index]\nSignIn: ui/auth.tsx:42",
+    ):
+        result = switch_thread("t2")
+
+    assert result["code_index_header"].startswith("[Frontend Thread")
+
+
+def test_dynamo_client_switch_thread_raises_when_target_missing():
+    client, table = make_client()
+    table.get_item.return_value = {}
+
+    with pytest.raises(ToolError, match="Thread not found: missing"): 
+        client.switch_thread("missing")
+
+    assert not client._client.transact_write_items.called
+
+
+def test_dynamo_client_switch_thread_writes_marker_and_target_meta():
+    client, table = make_client()
+    target_meta = {
+        "PK": "USER#testuser",
+        "SK": "THREAD#t2#META",
+        "CreatedAt": "2026-05-12T08:00:00Z",
+        "UpdatedAt": "2026-05-12T08:00:00Z",
+        "Version": 1,
+        "Name": "thread-two",
+    }
+    current_marker = {
+        "PK": "USER#testuser",
+        "SK": "THREAD#CURRENT#META",
+        "CreatedAt": "2026-05-12T07:00:00Z",
+        "UpdatedAt": "2026-05-12T07:00:00Z",
+        "Version": 1,
+        "CurrentThreadId": "t1",
+        "ActiveAt": "2026-05-12T07:00:00Z",
+    }
+
+    def get_item_side_effect(Key):
+        if Key["SK"] == "THREAD#CURRENT#META":
+            return {"Item": current_marker}
+        if Key["SK"] == "THREAD#t2#META":
+            return {"Item": target_meta}
+        return {}
+
+    table.get_item.side_effect = get_item_side_effect
+    client._client.transact_write_items.return_value = {}
+
+    result = client.switch_thread("t2")
+
+    assert result["thread_id"] == "t2"
+    client._client.transact_write_items.assert_called_once()
+
+    transact_items = client._client.transact_write_items.call_args.kwargs["TransactItems"]
+    sks = [item["Put"]["Item"]["SK"]["S"] for item in transact_items]
+    assert "THREAD#CURRENT#META" in sks
+    assert "THREAD#t2#META" in sks
+    assert len(sks) >= 2  # marker + target, previous meta optional depending on current state
+
+
+def test_dynamo_client_switch_thread_transaction_uses_metric_shape():
+    client, table = make_client()
+    target_meta = {
+        "PK": "USER#testuser",
+        "SK": "THREAD#t2#META",
+        "CreatedAt": "2026-05-12T08:00:00Z",
+        "UpdatedAt": "2026-05-12T08:00:00Z",
+        "Version": 1,
+        "Name": "thread-two",
+    }
+    current_marker = {
+        "PK": "USER#testuser",
+        "SK": "THREAD#CURRENT#META",
+        "CreatedAt": "2026-05-12T07:00:00Z",
+        "UpdatedAt": "2026-05-12T07:00:00Z",
+        "Version": 1,
+        "CurrentThreadId": "t1",
+        "ActiveAt": "2026-05-12T07:00:00Z",
+    }
+    previous_meta = {
+        "PK": "USER#testuser",
+        "SK": "THREAD#t1#META",
+        "CreatedAt": "2026-05-12T06:00:00Z",
+        "UpdatedAt": "2026-05-12T06:00:00Z",
+        "Version": 2,
+        "Name": "thread-one",
+    }
+
+    def get_item_side_effect(Key):
+        if Key["SK"] == "THREAD#CURRENT#META":
+            return {"Item": current_marker}
+        if Key["SK"] == "THREAD#t2#META":
+            return {"Item": target_meta}
+        if Key["SK"] == "THREAD#t1#META":
+            return {"Item": previous_meta}
+        return {}
+
+    table.get_item.side_effect = get_item_side_effect
+    client._client.transact_write_items.return_value = {}
+
+    client.switch_thread("t2")
+
+    transact_items = client._client.transact_write_items.call_args.kwargs["TransactItems"]
+    assert any(item["Put"]["Item"]["SK"]["S"] == "THREAD#t1#META" for item in transact_items)
+    assert any(item["Put"]["Item"]["SK"]["S"] == "THREAD#CURRENT#META" for item in transact_items)
+    assert any(item["Put"]["Item"]["SK"]["S"] == "THREAD#t2#META" for item in transact_items)

package/server/tools/tests/test_thread_command_skills.py

@@ -0,0 +1,54 @@
+"""
+Tests for Story 2.9: thread management slash-command skill files
+Run: pytest server/tools/tests/test_thread_command_skills.py -v
+"""
+from pathlib import Path
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+SKILLS_DIR = PLUGIN_DIR / "skills"
+
+
+COMMANDS = {
+    "new-thread": ["new_thread", "prompt", "thread name", "Created thread", "recovery"],
+    "switch-thread": ["list_threads", "switch_thread", "selection", "Switched", "recovery"],
+    "kill-thread": ["kill_thread", "Summarization in progress", "Killing", "recovery"],
+    "list-threads": ["list_threads", "Active", "message_count", "recovery"],
+    "recall": ["recall_memory", "query", "results", "recovery"],
+}
+
+
+def _read_skill(command: str) -> str:
+    return (SKILLS_DIR / command / "SKILL.md").read_text()
+
+
+def test_all_thread_command_skill_files_exist():
+    for command in COMMANDS:
+        path = SKILLS_DIR / command / "SKILL.md"
+        assert path.exists(), f"Missing {path}"
+
+
+def test_skill_files_have_frontmatter_name_and_description():
+    for command in COMMANDS:
+        text = _read_skill(command)
+        assert text.startswith("---\n")
+        assert f"name: {command}" in text
+        assert "description:" in text
+
+
+def test_skill_files_reference_required_tools_and_confirmations():
+    for command, required_phrases in COMMANDS.items():
+        text = _read_skill(command)
+        for phrase in required_phrases:
+            assert phrase in text, f"{command} missing {phrase!r}"
+
+
+def test_switch_thread_requires_listing_before_switching():
+    text = _read_skill("switch-thread")
+    assert text.index("list_threads") < text.index("switch_thread")
+
+
+def test_error_handling_mentions_failed_operation_and_next_steps():
+    for command in COMMANDS:
+        text = _read_skill(command).lower()
+        assert "failed operation" in text
+        assert "recovery steps" in text

package/server/tools/tests/test_thread_resolver.py

@@ -0,0 +1,165 @@
+"""
+Tests for Story 2.10: fuzzy thread name matching
+Run: pytest server/tools/tests/test_thread_resolver.py -v
+"""
+from pathlib import Path
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from mcp.shared.exceptions import McpError
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PLUGIN_DIR))
+
+
+THREADS = [
+    {
+        "thread_id": "gemma-v2",
+        "name": "Gemma Fine-Tuning v2",
+        "status": "active",
+        "last_activity": "2026-05-12T10:00:00Z",
+        "message_count": 5,
+    },
+    {
+        "thread_id": "eval",
+        "name": "Gemma Eval Run",
+        "status": "active",
+        "last_activity": "2026-05-11T10:00:00Z",
+        "message_count": 2,
+    },
+    {
+        "thread_id": "abc",
+        "name": "ABC",
+        "status": "active",
+        "last_activity": "2026-05-10T10:00:00Z",
+        "message_count": 1,
+    },
+]
+
+
+def test_resolve_thread_name_single_match_uses_extract_with_cutoff():
+    from server.tools.thread_resolver import resolve_thread_name
+
+    with patch("server.tools.thread_resolver.process.extract") as extract:
+        extract.return_value = [("Gemma Fine-Tuning v2", 90, 0)]
+        result = resolve_thread_name("Gemma Fine", THREADS)
+
+    extract.assert_called_once()
+    assert extract.call_args.kwargs["score_cutoff"] == 70
+    assert result == {
+        "status": "resolved",
+        "thread_id": "gemma-v2",
+        "name": "Gemma Fine-Tuning v2",
+        "message": "Switching to thread: Gemma Fine-Tuning v2",
+    }
+
+
+def test_resolve_thread_name_ambiguous_matches_returns_choices():
+    from server.tools.thread_resolver import resolve_thread_name
+
+    result = resolve_thread_name("Gemma", THREADS)
+
+    assert result["status"] == "ambiguous"
+    assert result["message"] == "Did you mean: [1] Gemma Fine-Tuning v2, [2] Gemma Eval Run?"
+    assert [match["thread_id"] for match in result["matches"]] == ["gemma-v2", "eval"]
+
+
+def test_resolve_thread_name_no_match_raises_invalid_request_mcp_error():
+    from server.tools.thread_resolver import resolve_thread_name
+
+    with pytest.raises(McpError) as exc_info:
+        resolve_thread_name("Nope", THREADS)
+
+    error = exc_info.value.error
+    assert error.code == -32600
+    assert "No thread found matching 'Nope'" in error.message
+    assert "run list_threads" in error.message
+
+
+def test_resolve_thread_name_three_character_thread_names_are_matchable():
+    from server.tools.thread_resolver import resolve_thread_name
+
+    result = resolve_thread_name("ABC", THREADS)
+
+    assert result["status"] == "resolved"
+    assert result["thread_id"] == "abc"
+    assert result["name"] == "ABC"
+
+
+def test_switch_thread_by_name_passes_resolved_thread_id_to_switch_thread():
+    import server.tools.tylor as tylor_mod
+
+    mock_db = MagicMock()
+    mock_db.query_all.return_value = [
+        {
+            "SK": "THREAD#gemma-v2#META",
+            "Name": "Gemma Fine-Tuning v2",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 5,
+        }
+    ]
+    mock_db.switch_thread.return_value = {
+        "thread_id": "gemma-v2",
+        "status": "switched",
+        "switched_at": "2026-05-12T10:01:00Z",
+    }
+
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        result = tylor_mod.switch_thread_by_name("Gemma")
+
+    mock_db.switch_thread.assert_called_once_with("gemma-v2")
+    assert result["thread_id"] == "gemma-v2"
+    assert result["name"] == "Gemma Fine-Tuning v2"
+    assert result["message"] == "Switching to thread: Gemma Fine-Tuning v2"
+
+
+def test_switch_thread_by_name_ambiguous_match_does_not_switch():
+    import server.tools.tylor as tylor_mod
+
+    mock_db = MagicMock()
+    mock_db.query_all.return_value = [
+        {
+            "SK": "THREAD#gemma-v2#META",
+            "Name": "Gemma Fine-Tuning v2",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 5,
+        },
+        {
+            "SK": "THREAD#eval#META",
+            "Name": "Gemma Eval Run",
+            "Status": "active",
+            "LastActivity": "2026-05-11T10:00:00Z",
+            "MessageCount": 2,
+        },
+    ]
+
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        result = tylor_mod.switch_thread_by_name("Gemma")
+
+    mock_db.switch_thread.assert_not_called()
+    assert result["status"] == "ambiguous"
+    assert "Did you mean" in result["message"]
+
+
+def test_switch_thread_by_name_normalizes_unexpected_switch_failures():
+    import server.tools.tylor as tylor_mod
+    from mcp.server.fastmcp.exceptions import ToolError
+
+    mock_db = MagicMock()
+    mock_db.query_all.return_value = [
+        {
+            "SK": "THREAD#gemma-v2#META",
+            "Name": "Gemma Fine-Tuning v2",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 5,
+        }
+    ]
+    mock_db.switch_thread.side_effect = RuntimeError("dynamo exploded")
+
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        with pytest.raises(ToolError, match="SwThread failed"):
+            tylor_mod.switch_thread_by_name("Gemma")