tylor-mcp 1.0.0

package/server/tools/tests/test_agents.py

@@ -0,0 +1,246 @@
+"""
+Tests for Story 3.2: spawn_agent and list_personas tools
+Run: pytest server/tools/tests/test_agents.py -v
+"""
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from mcp.shared.exceptions import McpError
+from mcp.types import INVALID_PARAMS
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+
+
+class FakeDb:
+    def __init__(self, meta: dict | None) -> None:
+        self.meta = meta
+        self.agent_outputs = []
+        self.agent_handoffs = []
+        self.agent_states = []
+
+    def get_thread_meta(self, thread_id: str) -> dict | None:
+        return self.meta
+
+    def put_agent_output(self, thread_id: str, agent_id: str, output: str, task: str | None = None) -> dict:
+        item = {
+            "SK": f"THREAD#{thread_id}#AGENT#{agent_id}#OUT#2026-05-12T00:00:00Z",
+            "ThreadId": thread_id,
+            "AgentId": agent_id,
+            "Output": output,
+            "Task": task,
+        }
+        self.agent_outputs.append(item)
+        return item
+
+    def put_agent_handoff(self, thread_id: str, agent_id: str, handoff_state: dict) -> dict:
+        item = {
+            "SK": f"THREAD#{thread_id}#AGENT#{agent_id}#HANDOFF#2026-05-12T00:00:00Z",
+            "ThreadId": thread_id,
+            "AgentId": agent_id,
+            "HandoffState": handoff_state,
+        }
+        self.agent_handoffs.append(item)
+        return item
+
+    def put_agent_state(self, thread_id: str, agent_id: str, state: dict) -> dict:
+        item = {
+            "SK": f"THREAD#{thread_id}#AGENT#{agent_id}#STATE",
+            "ThreadId": thread_id,
+            "AgentId": agent_id,
+            **state,
+        }
+        self.agent_states.append(item)
+        return item
+
+
+def test_list_personas_returns_four_personas_with_summaries_and_categories():
+    from server.tools.agents import list_personas
+
+    result = list_personas()
+
+    assert set(result.keys()) == {"personas"}
+    personas = result["personas"]
+    assert {p["name"] for p in personas} == {"analyst", "ceo", "code_agent", "cto"}
+
+    for persona in personas:
+        assert persona["role_summary"]
+        assert persona["ecc_tool_categories"]
+        assert all(c.startswith("ecc/") for c in persona["ecc_tool_categories"])
+
+
+def test_spawn_agent_initializes_known_persona_in_active_thread_with_scoped_tools():
+    from server.tools.agents import spawn_agent
+
+    db = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#META", "Status": "active"})
+
+    with patch("server.tools.agents._get_db", return_value=db):
+        result = spawn_agent(
+            persona="code_agent",
+            thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+            task="Implement the next story.",
+        )
+
+    assert result["agent_id"].startswith("agent_")
+    assert result["persona"] == "code_agent"
+    assert result["thread_id"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"
+    assert result["tools_loaded"] == ["ecc/web", "ecc/data", "ecc/pipeline"]
+    assert "Senior implementation engineer" in result["role_prompt"]
+    assert "Implement the next story." in result["task"]
+    assert result["state_sk"].startswith(f"THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#AGENT#{result['agent_id']}#STATE")
+    assert db.agent_states[0]["ThreadId"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"
+    assert db.agent_states[0]["Status"] == "active"
+    assert db.agent_states[0]["Persona"] == "code_agent"
+    assert db.agent_states[0]["ToolsLoaded"] == ["ecc/web", "ecc/data", "ecc/pipeline"]
+
+
+def test_spawn_agent_keeps_parallel_thread_agents_scoped_to_own_thread():
+    from server.tools.agents import spawn_agent
+
+    db_alpha = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2#META", "Status": "active"})
+    db_beta = FakeDb({"SK": "THREAD#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb#META", "Status": "active"})
+
+    with patch("server.tools.agents._get_db", return_value=db_alpha):
+        alpha = spawn_agent(
+            persona="analyst",
+            thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2",
+            task="Analyze alpha.",
+        )
+
+    with patch("server.tools.agents._get_db", return_value=db_beta):
+        beta = spawn_agent(
+            persona="cto",
+            thread_id="bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+            task="Analyze beta.",
+        )
+
+    assert alpha["thread_id"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2"
+    assert beta["thread_id"] == "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    assert db_alpha.agent_states[0]["ThreadId"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2"
+    assert db_beta.agent_states[0]["ThreadId"] == "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    assert "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" not in db_alpha.agent_states[0]["SK"]
+    assert "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2" not in db_beta.agent_states[0]["SK"]
+
+
+def test_spawn_agent_rejects_inactive_thread():
+    from server.tools.agents import spawn_agent
+
+    db = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#META", "Status": "killed"})
+
+    with pytest.raises(McpError) as excinfo:
+        with patch("server.tools.agents._get_db", return_value=db):
+            spawn_agent(persona="analyst", thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", task="Analyze market.")
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert "Thread is not active: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1" in excinfo.value.error.message
+
+
+def test_spawn_agent_unknown_persona_raises_invalid_params_with_persona_list():
+    from server.tools.agents import spawn_agent
+
+    with pytest.raises(McpError) as excinfo:
+        spawn_agent(persona="designer", thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", task="Make UI.")
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    message = excinfo.value.error.message
+    assert "Unknown persona: designer" in message
+    assert "Available personas:" in message
+    assert "code_agent" in message
+    assert "analyst" in message
+    assert "ceo" in message
+    assert "cto" in message
+
+
+def test_spawn_agent_rejects_persona_file_outside_allowlist(tmp_path):
+    from server.tools import personas as personas_mod
+    from server.tools.agents import spawn_agent
+
+    persona_dir = tmp_path / "personas"
+    persona_dir.mkdir()
+    (persona_dir / "designer.md").write_text(
+        "# Designer\n\n"
+        "## Role Description\nDesign role.\n\n"
+        "## Communication Style\nDirect.\n\n"
+        "## ECC Tool Categories\n- `ecc/web`\n",
+        encoding="utf-8",
+    )
+
+    with patch.object(personas_mod, "PERSONAS_DIR", persona_dir):
+        with pytest.raises(McpError) as excinfo:
+            spawn_agent(persona="designer", thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", task="Make UI.")
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert "Unknown persona: designer" in excinfo.value.error.message
+
+
+def test_persist_agent_output_writes_thread_scoped_dynamo_item_and_indexes_memory():
+    from server.tools.agents import persist_agent_output
+
+    db = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#META", "Status": "active"})
+    memory = MagicMock()
+    memory.index_memory.return_value = "memory-doc-1"
+
+    with patch("server.tools.agents._get_db", return_value=db), patch(
+        "server.tools.agents._get_memory_client", return_value=memory
+    ):
+        result = persist_agent_output(
+            thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+            agent_id="agent_a",
+            output="Agent A found the launch risk.",
+            task="Assess launch risk.",
+        )
+
+    assert result["thread_id"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"
+    assert result["agent_id"] == "agent_a"
+    assert result["output_sk"].startswith("THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#AGENT#agent_a#OUT#")
+    assert result["memory_id"] == "memory-doc-1"
+    assert db.agent_outputs[0]["ThreadId"] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"
+    assert db.agent_outputs[0]["Output"] == "Agent A found the launch risk."
+    memory.index_memory.assert_called_once_with(
+        thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+        fact="Agent A found the launch risk.",
+        metadata={
+            "source": "agent_output",
+            "agent_id": "agent_a",
+            "agent_output_sk": result["output_sk"],
+        },
+    )
+
+
+def test_persist_agent_output_preserves_handoff_state_as_distinct_item():
+    from server.tools.agents import persist_agent_output
+
+    db = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#META", "Status": "active"})
+    memory = MagicMock()
+    memory.index_memory.return_value = "memory-doc-1"
+    handoff = {"next_agent": "agent_b", "summary": "Use risk findings in plan."}
+
+    with patch("server.tools.agents._get_db", return_value=db), patch(
+        "server.tools.agents._get_memory_client", return_value=memory
+    ):
+        result = persist_agent_output(
+            thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+            agent_id="agent_a",
+            output="Agent A found the launch risk.",
+            handoff_state=handoff,
+        )
+
+    assert result["handoff_sk"].startswith("THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#AGENT#agent_a#HANDOFF#")
+    assert db.agent_outputs[0]["SK"] != db.agent_handoffs[0]["SK"]
+    assert db.agent_handoffs[0]["HandoffState"] == handoff
+
+
+def test_persist_agent_output_rejects_cross_thread_agent_id():
+    from server.tools.agents import persist_agent_output
+
+    db = FakeDb({"SK": "THREAD#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1#META", "Status": "active"})
+    with pytest.raises(McpError) as excinfo:
+        with patch("server.tools.agents._get_db", return_value=db):
+            persist_agent_output(
+                thread_id="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+                agent_id="THREAD#other#AGENT#agent_a",
+                output="bad",
+            )
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert "Invalid agent_id" in excinfo.value.error.message

package/server/tools/tests/test_code_index.py

@@ -0,0 +1,108 @@
+"""Tests for Story 2.11: thread-scoped code index."""
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+
+def test_save_memory_stores_typed_code_index_fact():
+    from server.tools.tylor import save_memory
+
+    memory = MagicMock()
+    memory.index_memory.return_value = "doc-1"
+
+    with patch("server.tools.tylor._get_memory_client", return_value=memory):
+        result = save_memory(
+            thread_id="t1",
+            fact="SignIn: ui/auth.tsx:42 — login form component",
+            fact_type="code_index",
+        )
+
+    memory.index_memory.assert_called_once_with(
+        thread_id="t1",
+        fact="SignIn: ui/auth.tsx:42 — login form component",
+        metadata={"type": "code_index"},
+    )
+    assert result == {"status": "saved", "thread_id": "t1", "memory_id": "doc-1", "type": "code_index"}
+
+
+def test_recall_memory_filters_by_type_at_storage_layer():
+    from server.tools.tylor import recall_memory
+
+    memory = MagicMock()
+    memory.search_memory.return_value = [{"content": "SignIn: ui/auth.tsx:42"}]
+
+    with patch("server.tools.tylor._get_memory_client", return_value=memory):
+        result = recall_memory(thread_id="t1", query="SignIn", fact_type="code_index")
+
+    # storage layer receives `type=` (its own parameter name)
+    memory.search_memory.assert_called_once_with(
+        thread_id="t1",
+        query="SignIn",
+        k=5,
+        type="code_index",
+    )
+    assert result["results"][0]["content"].startswith("SignIn")
+
+
+def test_code_index_header_injected_on_session_start_with_budget():
+    from server.tools.hooks import session_start_message
+
+    db = MagicMock()
+    db.get_current_thread_marker.return_value = {
+        "CurrentThreadId": "t1",
+        "ActiveAt": "2026-05-13T00:00:00Z",
+    }
+    db.get_thread_meta.return_value = {"Name": "Frontend", "Status": "active", "MessageCount": 3}
+    memory = MagicMock()
+    memory.search_memory.return_value = [
+        {"content": f"Symbol{i}: src/file{i}.tsx:{i} — component", "created_at": f"2026-05-13T00:00:{i:02d}Z"}
+        for i in range(30)
+    ]
+
+    def list_threads():
+        return {"threads": [{"thread_id": "t1", "name": "Frontend", "status": "active", "message_count": 3}]}
+
+    message = session_start_message(db=db, list_threads_fn=list_threads, memory_client=memory)
+
+    assert "[Frontend Thread — Code Index]" in message
+    header = message.split("agent101 active thread context:", 1)[0]
+    assert len(header.split()) <= 150
+    # storage layer receives `type=`
+    memory.search_memory.assert_called_once_with(
+        thread_id="t1",
+        query="code index",
+        k=30,
+        type="code_index",
+    )
+
+
+def test_post_tool_use_indexes_read_file_symbol(tmp_path):
+    from server.tools.hooks import index_code_file_for_active_thread
+
+    source = tmp_path / "SignIn.tsx"
+    source.write_text("export function SignIn() {\n  return <form />\n}\n", encoding="utf-8")
+    db = MagicMock()
+    db.get_current_thread_marker.return_value = {"CurrentThreadId": "t1"}
+    memory = MagicMock()
+    memory.index_memory.return_value = "doc-1"
+
+    result = index_code_file_for_active_thread(str(source), db=db, memory_client=memory,
+                                               project_root=tmp_path)
+
+    assert result["status"] == "indexed"
+    fact = memory.index_memory.call_args.kwargs["fact"]
+    assert fact.startswith("SignIn:")
+    # path should be relative (just the filename when project_root=tmp_path)
+    assert "SignIn.tsx:1" in fact
+    assert len(fact.split()) <= 30
+    assert memory.index_memory.call_args.kwargs["metadata"]["type"] == "code_index"
+
+
+def test_post_tool_use_skips_config_files(tmp_path):
+    from server.tools.hooks import index_code_file_for_active_thread
+
+    config = tmp_path / "vite.config.ts"
+    config.write_text("export default {}\n", encoding="utf-8")
+
+    result = index_code_file_for_active_thread(str(config), db=MagicMock(), memory_client=MagicMock())
+
+    assert result == {"status": "skipped", "reason": "no_indexable_symbol"}

package/server/tools/tests/test_ecc_tools.py

@@ -0,0 +1,51 @@
+"""
+Tests for Story 4.1: ECC tool modules initial five categories.
+Run: pytest server/tools/tests/test_ecc_tools.py -v
+"""
+import asyncio
+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
+
+EXPECTED_GROUPS = {
+    "ecc/web": {"web_scrape", "web_fetch"},
+    "ecc/data": {"dataset_manager", "data_clean", "data_transform"},
+    "ecc/presentation": {"build_pptx", "build_doc"},
+    "ecc/diagrams": {"diagram_gen", "flowchart_gen"},
+    "ecc/pipeline": {"pipeline_builder", "pipeline_run"},
+}
+
+
+def _registered_tools() -> set[str]:
+    from server.tools._mcp import mcp
+
+    tools = asyncio.run(mcp.list_tools())
+    return {tool.name for tool in tools}
+
+
+@pytest.mark.parametrize("tool_group,expected_tools", EXPECTED_GROUPS.items())
+def test_load_skill_tools_registers_ecc_group_tools(tool_group, expected_tools):
+    from server.tools.registry import load_skill_tools
+
+    result = load_skill_tools(tool_group)
+
+    assert result == {
+        "tool_group": tool_group,
+        "status": "loaded",
+        "tools": sorted(expected_tools),
+    }
+    assert expected_tools <= _registered_tools()
+
+
+def test_load_skill_tools_unknown_category_raises_invalid_params():
+    from server.tools.registry import load_skill_tools
+
+    with pytest.raises(McpError) as excinfo:
+        load_skill_tools("ecc/unknown")
+
+    assert excinfo.value.error.code == INVALID_PARAMS
+    assert excinfo.value.error.message == "Unknown skill category: ecc/unknown"