tylor-mcp 1.0.0

package/server/tools/tests/test_help_agent101.py

@@ -0,0 +1,149 @@
+"""
+Tests for Story 4.5: /help-agent101 slash command.
+Run: pytest server/tools/tests/test_help_agent101.py -v
+"""
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+SKILLS_DIR = PLUGIN_DIR / "skills"
+
+
+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_help_agent101_skill_file_exists_and_describes_live_help_tool():
+    path = SKILLS_DIR / "help-agent101" / "SKILL.md"
+    assert path.exists()
+    text = path.read_text(encoding="utf-8")
+    assert text.startswith("---\n")
+    assert "name: help-agent101" in text
+    assert "help_agent101" in text
+    assert "list_registry" in text
+    assert "list_personas" in text
+
+
+def test_help_index_lists_commands_tools_registry_personas_and_ecc(tmp_path):
+    from server.tools import help as help_mod
+    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 = help_mod.build_help_index()
+
+    assert {command["command"] for command in result["slash_commands"]} >= {
+        "/new-thread",
+        "/switch-thread",
+        "/kill-thread",
+        "/list-threads",
+        "/recall",
+        "/add-skill",
+        "/open-threads-ui",
+        "/set-sandbox",
+        "/afk-status",
+    }
+    assert {tool["name"] for tool in result["tier1_tools"]} >= {
+        "new_thread",
+        "switch_thread",
+        "switch_thread_by_name",
+        "kill_thread",
+        "recall_memory",
+        "list_threads",
+        "list_personas",
+        "spawn_agent",
+        "load_skill_tools",
+        "list_registry",
+        "help_agent101",
+        "set_sandbox",
+        "execute_in_sandbox",
+        "execute_with_recovery",
+        "start_afk",
+        "afk_status",
+        "pause_afk",
+    }
+    assert result["registered_skills"] == [
+        {
+            "name": "bmad",
+            "trigger": "Use when user wants to create a PRD.",
+        }
+    ]
+    assert {persona["name"] for persona in result["personas"]} == {
+        "analyst",
+        "ceo",
+        "code_agent",
+        "cto",
+    }
+    assert result["ecc_categories"]["ecc/web"] == ["web_fetch", "web_scrape"]
+    assert result["ecc_categories"]["ecc/pipeline"] == [
+        "pipeline_builder",
+        "pipeline_run",
+    ]
+
+
+def test_help_agent101_reads_registry_fresh_each_invocation(tmp_path):
+    from server.tools import help as help_mod
+    from server.tools import registry as registry_mod
+
+    registry_path = tmp_path / "registry.json"
+    _write_registry(
+        registry_path,
+        [
+            {
+                "name": "alpha",
+                "trigger_description": "Use for alpha workflows.",
+                "keywords": ["alpha"],
+                "tool_count": 1,
+            }
+        ],
+    )
+
+    with patch.object(registry_mod, "REGISTRY_PATH", registry_path):
+        first = help_mod.help_agent101()
+        _write_registry(
+            registry_path,
+            [
+                {
+                    "name": "beta",
+                    "trigger_description": "Use for beta workflows.",
+                    "keywords": ["beta"],
+                    "tool_count": 1,
+                }
+            ],
+        )
+        second = help_mod.help_agent101()
+
+    assert first["registered_skills"] == [
+        {"name": "alpha", "trigger": "Use for alpha workflows."}
+    ]
+    assert second["registered_skills"] == [
+        {"name": "beta", "trigger": "Use for beta workflows."}
+    ]
+
+
+def test_help_agent101_registered_as_tier1_tool():
+    import asyncio
+    import server.main  # noqa: F401
+    from server.tools._mcp import mcp
+
+    tools = asyncio.run(mcp.list_tools())
+    assert "help_agent101" in {tool.name for tool in tools}

package/server/tools/tests/test_hooks.py

@@ -0,0 +1,124 @@
+"""
+Tests for Story 2.8: Claude Code lifecycle hooks
+Run: pytest server/tools/tests/test_hooks.py -v
+"""
+from pathlib import Path
+import subprocess
+import sys
+from unittest.mock import MagicMock, patch
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PLUGIN_DIR))
+
+
+class FakeDynamo:
+    CURRENT_THREAD_SK = "THREAD#CURRENT#META"
+
+    def __init__(self):
+        self.puts = []
+        self.current = {
+            "SK": self.CURRENT_THREAD_SK,
+            "CurrentThreadId": "t1",
+            "ActiveAt": "2026-05-12T00:00:00Z",
+        }
+        self.meta = {
+            "SK": "THREAD#t1#META",
+            "Name": "Build hooks",
+            "Status": "active",
+            "MessageCount": 4,
+        }
+
+    def get_current_thread_marker(self):
+        return self.current
+
+    def get_thread_meta(self, thread_id):
+        return self.meta if thread_id == "t1" else None
+
+    def put_item(self, sk, attributes):
+        self.puts.append((sk, attributes))
+        return {"SK": sk, **attributes}
+
+
+def test_session_start_surfaces_active_thread_context():
+    from server.tools.hooks import session_start_message
+
+    db = FakeDynamo()
+
+    def fake_list_threads():
+        return {
+            "threads": [
+                {
+                    "thread_id": "t1",
+                    "name": "Build hooks",
+                    "status": "active",
+                    "last_activity": "2026-05-12T00:00:00Z",
+                    "message_count": 4,
+                }
+            ]
+        }
+
+    message = session_start_message(db=db, list_threads_fn=fake_list_threads)
+
+    assert "agent101 active thread context" in message
+    assert "Build hooks" in message
+    assert "t1" in message
+    assert "Acknowledge this active thread" in message
+
+
+def test_session_checkpoint_updates_current_thread_meta():
+    from server.tools.hooks import checkpoint_current_thread
+
+    db = FakeDynamo()
+    result = checkpoint_current_thread(db=db, now_fn=lambda: "2026-05-12T01:02:03Z")
+
+    assert result["status"] == "checkpointed"
+    assert result["thread_id"] == "t1"
+    assert db.puts == [
+        (
+            "THREAD#t1#META",
+            {
+                "SK": "THREAD#t1#META",
+                "Name": "Build hooks",
+                "Status": "active",
+                "MessageCount": 4,
+                "LastActivity": "2026-05-12T01:02:03Z",
+                "CheckpointAt": "2026-05-12T01:02:03Z",
+            },
+        )
+    ]
+
+
+def test_kill_thread_trigger_dispatches_background_process_without_waiting():
+    from server.tools.hooks import dispatch_kill_thread_summary
+
+    proc = MagicMock()
+    with patch("subprocess.Popen", return_value=proc) as popen:
+        result = dispatch_kill_thread_summary(
+            "t1",
+            project_root=PLUGIN_DIR,
+            python_executable="python-test",
+        )
+
+    assert result == {"status": "dispatched", "thread_id": "t1"}
+    args = popen.call_args.args[0]
+    assert args[:4] == [
+        "python-test",
+        "-m",
+        "server.tools.hooks",
+        "summarize-thread",
+    ]
+    assert "t1" in args
+    assert popen.call_args.kwargs["cwd"] == str(PLUGIN_DIR)
+    assert popen.call_args.kwargs["stdout"] == subprocess.DEVNULL
+
+
+def test_hook_shell_scripts_exist_and_are_executable():
+    for rel_path in (
+        "hooks/session-start.sh",
+        "hooks/session-checkpoint.sh",
+        "hooks/kill-thread-trigger.sh",
+        "hooks/post-tool-use-code-index.sh",
+    ):
+        path = PLUGIN_DIR / rel_path
+        assert path.exists()
+        assert path.stat().st_mode & 0o111

package/server/tools/tests/test_kill_thread.py

@@ -0,0 +1,125 @@
+"""
+Tests for Story 2.7: kill_thread and async Bedrock summarizer
+Run: pytest server/tools/tests/test_kill_thread.py -v
+"""
+import asyncio
+from pathlib import Path
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(PLUGIN_DIR))
+
+
+class FakeDynamo:
+    def __init__(self):
+        self.items = {}
+        self.puts = []
+        self.messages = [
+            {"SK": "THREAD#t1#MSG#001", "Role": "user", "Content": "first"},
+            {"SK": "THREAD#t1#MSG#002", "Role": "assistant", "Content": "second"},
+        ]
+
+    def get_thread_meta(self, thread_id):
+        return {
+            "SK": f"THREAD#{thread_id}#META",
+            "Name": "Test thread",
+            "Status": "active",
+            "MessageCount": len(self.messages),
+        }
+
+    def query_thread(self, thread_id, sk_prefix):
+        if sk_prefix.endswith("#MSG#"):
+            return list(self.messages)
+        return []
+
+    def put_item(self, sk, attributes):
+        item = {"SK": sk, **attributes}
+        self.items[sk] = item
+        self.puts.append((sk, attributes))
+        return item
+
+
+class FakeBedrock:
+    def __init__(self, text=None, error=None):
+        self.text = text
+        self.error = error
+        self.calls = []
+
+    def invoke_model(self, **kwargs):
+        self.calls.append(kwargs)
+        if self.error:
+            raise self.error
+        body = MagicMock()
+        body.read.return_value = (
+            b'{"content":[{"type":"text","text":"' + self.text.encode("utf-8") + b'"}]}'
+        )
+        return {"body": body}
+
+
+def test_kill_thread_returns_immediately_without_dispatching_task():
+    """kill_thread is now sync; summarization is dispatched by the PostToolUse hook."""
+    from server.tools.tylor import kill_thread
+
+    with patch("server.tools.tylor._get_db", return_value=FakeDynamo()):
+        result = kill_thread("t1")
+
+    assert result == {
+        "status": "killing",
+        "thread_id": "t1",
+        "message": "Summarization in progress",
+    }
+
+
+def test_summarize_thread_success_writes_summary_and_marks_thread_killed():
+    from server.tools.summarizer import summarize_thread
+
+    db = FakeDynamo()
+    bedrock = FakeBedrock(text="Permanent summary")
+
+    asyncio.run(
+        summarize_thread(
+            "t1",
+            db=db,
+            bedrock_client=bedrock,
+            model_id="opus-test",
+        )
+    )
+
+    summary = db.items["THREAD#t1#SUMMARY"]
+    meta = db.items["THREAD#t1#META"]
+    assert summary["Summary"] == "Permanent summary"
+    assert summary["SummaryType"] == "bedrock_opus"
+    assert meta["Status"] == "killed"
+    assert bedrock.calls[0]["modelId"] == "opus-test"
+
+
+def test_summarize_thread_failure_stores_raw_fallback_and_logs_failure():
+    from server.tools.summarizer import summarize_thread
+
+    db = FakeDynamo()
+    bedrock = FakeBedrock(error=RuntimeError("bedrock down"))
+
+    asyncio.run(
+        summarize_thread(
+            "t1",
+            db=db,
+            bedrock_client=bedrock,
+            model_id="opus-test",
+        )
+    )
+
+    summary = db.items["THREAD#t1#SUMMARY"]
+    meta = db.items["THREAD#t1#META"]
+    failure_logs = [
+        item for sk, item in db.items.items()
+        if sk.startswith("THREAD#t1#MSG#") and item.get("Role") == "system"
+    ]
+
+    assert summary["SummaryType"] == "raw_fallback"
+    assert "user: first" in summary["Summary"]
+    assert "assistant: second" in summary["Summary"]
+    assert "bedrock down" in summary["Error"]
+    assert meta["Status"] == "killed"
+    assert failure_logs
+    assert "bedrock down" in failure_logs[0]["Content"]

package/server/tools/tests/test_new_thread_list_threads.py

@@ -0,0 +1,293 @@
+"""
+Tests for Story 2.3: new_thread & list_threads tools
+Run: pytest server/tools/tests/test_new_thread_list_threads.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
+# Import the tool functions directly for unit testing
+import server.tools.tylor as tylor_mod
+from server.tools.tylor import _validate_name, new_thread, list_threads
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_db_mock(existing_items=None):
+    """Return a mock DynamoClient."""
+    mock_db = MagicMock()
+    mock_db.query_all.return_value = existing_items or []
+    mock_db.put_item.side_effect = lambda sk, attrs: {
+        **attrs, "PK": "USER#default", "SK": sk,
+        "CreatedAt": "2026-05-12T10:00:00Z",
+        "UpdatedAt": "2026-05-12T10:00:00Z",
+        "Version": 1,
+    }
+    return mock_db
+
+
+def _call_new_thread(name: str, existing_items=None):
+    """Call new_thread with a mocked DynamoClient."""
+    mock_db = _make_db_mock(existing_items)
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        return new_thread(name), mock_db
+
+
+def _call_list_threads(items=None):
+    """Call list_threads with a mocked DynamoClient."""
+    mock_db = _make_db_mock(items)
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        return list_threads(), mock_db
+
+
+# ---------------------------------------------------------------------------
+# AC4: Name length validation
+# ---------------------------------------------------------------------------
+
+def test_new_thread_rejects_name_too_short():
+    with pytest.raises(ToolError, match="3–64 characters"):
+        new_thread("ab")
+
+
+def test_new_thread_rejects_name_too_long():
+    with pytest.raises(ToolError, match="3–64 characters"):
+        new_thread("x" * 65)
+
+
+def test_new_thread_accepts_name_at_min_length():
+    result, db = _call_new_thread("abc")
+    assert result["name"] == "abc"
+    db.put_item.assert_called_once()
+
+
+def test_new_thread_accepts_name_at_max_length():
+    result, db = _call_new_thread("x" * 64)
+    assert result["name"] == "x" * 64
+
+
+# ---------------------------------------------------------------------------
+# AC5: Character and whitespace validation
+# ---------------------------------------------------------------------------
+
+def test_new_thread_rejects_whitespace_only():
+    with pytest.raises(ToolError, match="invalid characters"):
+        new_thread("   ")
+
+
+def test_new_thread_rejects_only_spaces_exact_min():
+    with pytest.raises(ToolError, match="invalid characters"):
+        new_thread("   ")  # 3 spaces
+
+
+def test_new_thread_rejects_special_characters():
+    with pytest.raises(ToolError, match="invalid characters"):
+        new_thread("bad@name!")
+
+
+def test_new_thread_rejects_slash_characters():
+    with pytest.raises(ToolError, match="invalid characters"):
+        new_thread("my/thread")
+
+
+def test_new_thread_accepts_hyphens_underscores_spaces():
+    result, _ = _call_new_thread("my-thread_name test")
+    assert result["name"] == "my-thread_name test"
+
+
+def test_new_thread_accepts_alphanumeric():
+    result, _ = _call_new_thread("Project123")
+    assert result["name"] == "Project123"
+
+
+# ---------------------------------------------------------------------------
+# AC3: Duplicate name
+# ---------------------------------------------------------------------------
+
+def test_new_thread_rejects_duplicate_name():
+    existing = [
+        {
+            "SK": "THREAD#abc123#META",
+            "Name": "my-project",
+            "Status": "active",
+        }
+    ]
+    with pytest.raises(ToolError, match="already exists"):
+        _call_new_thread("my-project", existing_items=existing)
+
+
+def test_new_thread_allows_different_name_when_others_exist():
+    existing = [
+        {
+            "SK": "THREAD#abc123#META",
+            "Name": "other-project",
+            "Status": "active",
+        }
+    ]
+    result, db = _call_new_thread("new-project", existing_items=existing)
+    assert result["name"] == "new-project"
+    db.put_item.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# AC1: new_thread returns correct shape
+# ---------------------------------------------------------------------------
+
+def test_new_thread_returns_thread_id_name_created_at():
+    result, _ = _call_new_thread("alpha")
+    assert "thread_id" in result
+    assert "name" in result
+    assert "created_at" in result
+
+
+def test_new_thread_thread_id_is_hex_32chars():
+    result, _ = _call_new_thread("beta")
+    assert len(result["thread_id"]) == 32
+    assert all(c in "0123456789abcdef" for c in result["thread_id"])
+
+
+def test_new_thread_writes_correct_sk():
+    result, db = _call_new_thread("gamma")
+    thread_id = result["thread_id"]
+    call_sk = db.put_item.call_args.args[0]
+    assert call_sk == f"THREAD#{thread_id}#META"
+
+
+def test_new_thread_writes_status_active():
+    result, db = _call_new_thread("delta")
+    attrs = db.put_item.call_args.args[1]
+    assert attrs["Status"] == "active"
+    assert attrs["MessageCount"] == 0
+
+
+def test_new_thread_uniqueness_check_before_write():
+    """query_all must be called before put_item."""
+    mock_db = _make_db_mock()
+    call_order = []
+    mock_db.query_all.side_effect = lambda *a, **kw: call_order.append("query") or []
+    mock_db.put_item.side_effect = lambda sk, attrs: call_order.append("write") or {
+        **attrs, "SK": sk, "CreatedAt": "2026-05-12T10:00:00Z",
+        "UpdatedAt": "2026-05-12T10:00:00Z", "Version": 1,
+    }
+
+    with patch.object(tylor_mod, "_get_db", return_value=mock_db):
+        new_thread("epsilon")
+
+    assert call_order.index("query") < call_order.index("write")
+
+
+# ---------------------------------------------------------------------------
+# AC2: list_threads returns sorted threads
+# ---------------------------------------------------------------------------
+
+def test_list_threads_returns_empty_when_no_threads():
+    result, _ = _call_list_threads([])
+    assert result == {"threads": []}
+
+
+def test_list_threads_returns_correct_shape():
+    items = [
+        {
+            "SK": "THREAD#abc123#META",
+            "Name": "project-a",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 3,
+        }
+    ]
+    result, _ = _call_list_threads(items)
+    threads = result["threads"]
+    assert len(threads) == 1
+    t = threads[0]
+    assert t["thread_id"] == "abc123"
+    assert t["name"] == "project-a"
+    assert t["status"] == "active"
+    assert t["last_activity"] == "2026-05-12T10:00:00Z"
+    assert t["message_count"] == 3
+
+
+def test_list_threads_sorted_by_last_activity_descending():
+    items = [
+        {
+            "SK": "THREAD#aaa#META",
+            "Name": "old",
+            "Status": "active",
+            "LastActivity": "2026-05-10T10:00:00Z",
+            "MessageCount": 1,
+        },
+        {
+            "SK": "THREAD#bbb#META",
+            "Name": "new",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 5,
+        },
+        {
+            "SK": "THREAD#ccc#META",
+            "Name": "middle",
+            "Status": "active",
+            "LastActivity": "2026-05-11T10:00:00Z",
+            "MessageCount": 2,
+        },
+    ]
+    result, _ = _call_list_threads(items)
+    activities = [t["last_activity"] for t in result["threads"]]
+    assert activities == sorted(activities, reverse=True)
+    assert result["threads"][0]["name"] == "new"
+
+
+def test_list_threads_excludes_non_meta_items():
+    items = [
+        {
+            "SK": "THREAD#abc123#META",
+            "Name": "real-thread",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 0,
+        },
+        {
+            "SK": "THREAD#abc123#MSG#2026-05-12T10:00:00Z",
+            "Content": "a message",
+        },
+    ]
+    result, _ = _call_list_threads(items)
+    assert len(result["threads"]) == 1
+    assert result["threads"][0]["name"] == "real-thread"
+
+
+def test_list_threads_thread_id_extracted_correctly():
+    items = [
+        {
+            "SK": "THREAD#deadbeef1234567890abcdef12345678#META",
+            "Name": "extract-test",
+            "Status": "active",
+            "LastActivity": "2026-05-12T10:00:00Z",
+            "MessageCount": 0,
+        }
+    ]
+    result, _ = _call_list_threads(items)
+    assert result["threads"][0]["thread_id"] == "deadbeef1234567890abcdef12345678"
+
+
+# ---------------------------------------------------------------------------
+# query_all on DynamoClient
+# ---------------------------------------------------------------------------
+
+def test_query_all_method_exists_on_dynamo_client():
+    from server.storage.dynamo import DynamoClient
+    assert hasattr(DynamoClient, "query_all")
+
+
+def test_query_all_no_thread_isolation_check():
+    """query_all must NOT call _assert_thread_isolation."""
+    from server.storage.dynamo import DynamoClient
+    import inspect
+    source = inspect.getsource(DynamoClient.query_all)
+    assert "_assert_thread_isolation" not in source