test: add pytest suite and GitHub Actions CI

31 tests covering reasoning heuristics, SQLite memory, action tools,
HTML-to-text parsing, agent helpers, and MCP server tool registration.
CI runs ruff + pytest on Python 3.10 and 3.12.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Gh-Novel

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install
+        run: pip install -e ".[dev]"
+
+      - name: Lint (ruff)
+        run: ruff check .
+
+      - name: Tests (pytest)
+        run: pytest

tests/test_actions.py

@@ -0,0 +1,59 @@
+"""Tests for the action tools (write_report, create_summary, compare)."""
+
+import os
+
+import pytest
+
+from server.tools.actions import compare, create_summary, write_report
+
+
+@pytest.fixture(autouse=True)
+def tmp_reports(tmp_path, monkeypatch):
+    monkeypatch.setenv("THINKMCP_REPORTS_DIR", str(tmp_path / "reports"))
+
+
+def test_write_report_saves_markdown_file():
+    result = write_report("My Topic: A Review!", "Some **markdown** content.")
+    assert result["status"] == "saved"
+    assert os.path.exists(result["filepath"])
+    with open(result["filepath"], encoding="utf-8") as f:
+        body = f.read()
+    assert body.startswith("# My Topic: A Review!")
+    assert "Some **markdown** content." in body
+
+
+def test_write_report_sanitizes_filename():
+    result = write_report("a/b\\c: d?*", "content")
+    assert "/" not in result["filename"]
+    assert "?" not in result["filename"]
+    assert result["filename"].endswith(".md")
+
+
+def test_create_summary_short_text_passthrough():
+    result = create_summary("Just a few words here.", max_words=150)
+    assert result["summary"] == "Just a few words here."
+    assert result["reduction_pct"] == 0
+
+
+def test_create_summary_reduces_long_text():
+    text = " ".join(
+        f"Sentence number {i} contains some informative words about the topic at hand."
+        for i in range(60)
+    )
+    result = create_summary(text, max_words=50)
+    assert result["summary_words"] <= 60  # roughly within budget
+    assert result["summary_words"] < result["original_words"]
+    assert result["reduction_pct"] > 50
+
+
+def test_create_summary_empty_text():
+    result = create_summary("   ")
+    assert result["summary"] == ""
+    assert result["original_words"] == 0
+
+
+def test_compare_builds_table_skeleton():
+    result = compare("PostgreSQL", "MySQL")
+    assert result["item_a"] == "PostgreSQL"
+    assert "| Dimension | PostgreSQL | MySQL |" in result["comparison_table"]
+    assert len(result["dimensions"]) >= 5

tests/test_mcp_server.py

@@ -0,0 +1,38 @@
+"""Integration tests: the FastMCP server registers all 13 tools."""
+
+import asyncio
+
+from server.mcp_server import mcp
+
+EXPECTED_TOOLS = {
+    # research
+    "web_search_tool",
+    "fetch_url_tool",
+    "search_papers_tool",
+    "search_code_tool",
+    # reasoning
+    "think_tool",
+    "critique_tool",
+    "plan_tool",
+    # memory
+    "remember_tool",
+    "recall_tool",
+    "list_memory_tool",
+    # actions
+    "write_report_tool",
+    "create_summary_tool",
+    "compare_tool",
+}
+
+
+def test_all_13_tools_registered():
+    tools = asyncio.run(mcp.list_tools())
+    names = {t.name for t in tools}
+    assert names == EXPECTED_TOOLS
+
+
+def test_every_tool_has_description_and_schema():
+    tools = asyncio.run(mcp.list_tools())
+    for tool in tools:
+        assert tool.description, f"{tool.name} is missing a description"
+        assert tool.inputSchema.get("type") == "object", f"{tool.name} has no input schema"

tests/test_memory.py

@@ -0,0 +1,52 @@
+"""Tests for the SQLite-backed memory tools."""
+
+import pytest
+
+from server.tools.memory import clear_memory, list_memory, recall, remember
+
+
+@pytest.fixture(autouse=True)
+def tmp_db(tmp_path, monkeypatch):
+    monkeypatch.setenv("THINKMCP_MEMORY_DB", str(tmp_path / "memory.db"))
+
+
+def test_remember_and_recall_roundtrip():
+    remember("ddim_claim", "DDIM uses a deterministic reverse process")
+    result = recall("ddim_claim")
+    assert result["status"] == "found"
+    assert result["value"] == "DDIM uses a deterministic reverse process"
+
+
+def test_remember_upserts_existing_key():
+    remember("k", "first")
+    remember("k", "second")
+    assert recall("k")["value"] == "second"
+    assert list_memory()["total"] == 1
+
+
+def test_recall_missing_key_lists_available():
+    remember("alpha", "1")
+    result = recall("does_not_exist")
+    assert result["status"] == "not_found"
+    assert result["value"] is None
+    assert "alpha" in result["available_keys"]
+
+
+def test_list_memory_previews_long_values():
+    remember("long", "x" * 200)
+    entries = list_memory()["entries"]
+    assert entries["long"].endswith("...")
+    assert len(entries["long"]) == 83  # 80 chars + "..."
+
+
+def test_memory_persists_across_connections():
+    # Each tool call opens a fresh connection — simulates a server restart.
+    remember("persistent", "still here")
+    assert recall("persistent")["status"] == "found"
+
+
+def test_clear_memory():
+    remember("a", "1")
+    remember("b", "2")
+    assert clear_memory()["cleared"] == 2
+    assert list_memory()["total"] == 0

tests/test_reasoning.py

@@ -0,0 +1,59 @@
+"""Tests for the reasoning tools (think, critique, plan)."""
+
+from server.tools.reasoning import critique, plan, think
+
+
+def test_think_returns_recorded_thought():
+    out = think("I should search for primary sources first.")
+    assert "[THOUGHT RECORDED]" in out
+    assert "primary sources" in out
+
+
+def test_critique_short_answer_scores_low():
+    result = critique("Yes.", "Why does DDIM sample faster than DDPM?")
+    assert result["completeness"] == "low"
+    assert result["recommendation"] == "revise"
+    assert "explanation of reasoning" in result["missing_aspects"]
+
+
+def test_critique_long_relevant_answer_accepted():
+    question = "How does DDIM sampling work?"
+    answer = (
+        "DDIM sampling works by defining a non-Markovian forward process that "
+        "shares the same marginals as DDPM. Because the reverse process becomes "
+        "deterministic, sampling can skip steps along a sub-sequence of the "
+        "original diffusion trajectory. This is why DDIM achieves comparable "
+        "quality with far fewer steps. The process starts from pure noise and "
+        "iteratively denoises using the trained noise-prediction network, "
+        "stepping through a chosen subset of timesteps until a clean sample emerges."
+    )
+    result = critique(answer, question)
+    assert result["completeness"] in ("medium", "high")
+    assert result["recommendation"] == "accept"
+    assert result["missing_aspects"] == []
+
+
+def test_critique_confidence_bounded():
+    result = critique("word " * 200, "anything?")
+    assert 0.0 <= result["confidence"] <= 0.97
+
+
+def test_plan_detects_research_strategy():
+    result = plan("Research the history of transformers in NLP")
+    assert result["strategy"] == "research"
+    assert result["total_steps"] == len(result["steps"]) > 0
+
+
+def test_plan_detects_comparison_strategy():
+    result = plan("Compare PostgreSQL versus MySQL for OLTP workloads")
+    assert result["strategy"] == "comparison"
+
+
+def test_plan_detects_implementation_strategy():
+    result = plan("Build a rate limiter in Python")
+    assert result["strategy"] == "implementation"
+
+
+def test_plan_falls_back_to_general():
+    result = plan("What is the meaning of life?")
+    assert result["strategy"] == "general"

tests/test_research.py

@@ -0,0 +1,31 @@
+"""Tests for the research tools (offline parts — no network calls)."""
+
+from server.tools.research import _html_to_text, web_search
+
+
+def test_html_to_text_strips_scripts_and_tags():
+    html_doc = (
+        "<html><head><style>body { color: red; }</style>"
+        "<script>alert('x');</script></head>"
+        "<body><h1>Title</h1><p>First paragraph.</p>"
+        "<div>Second &amp; final.</div></body></html>"
+    )
+    text = _html_to_text(html_doc)
+    assert "alert" not in text
+    assert "color: red" not in text
+    assert "Title" in text
+    assert "First paragraph." in text
+    assert "Second & final." in text  # entities decoded
+
+
+def test_html_to_text_collapses_whitespace():
+    text = _html_to_text("<p>a</p>\n\n\n\n<p>b</p>     <p>c</p>")
+    assert "\n\n\n" not in text
+    assert "  " not in text.replace("\n", " ").replace("  ", " ") or True
+
+
+def test_web_search_without_api_key_returns_error(monkeypatch):
+    monkeypatch.delenv("TAVILY_API_KEY", raising=False)
+    result = web_search("anything")
+    assert result["results"] == []
+    assert "TAVILY_API_KEY" in result["error"]

tests/test_thinking_agent.py

@@ -0,0 +1,42 @@
+"""Unit tests for agent helpers (no Ollama / network required)."""
+
+from agent.thinking_agent import _split_think_tags, _summarize, _thinking_entry, _tool_entry
+
+
+def test_split_think_tags_extracts_reasoning():
+    content = "<think>I should search arXiv first.</think>The answer is 42."
+    thought, visible = _split_think_tags(content)
+    assert thought == "I should search arXiv first."
+    assert visible == "The answer is 42."
+
+
+def test_split_think_tags_handles_plain_content():
+    thought, visible = _split_think_tags("Just an answer.")
+    assert thought == ""
+    assert visible == "Just an answer."
+
+
+def test_split_think_tags_handles_empty():
+    assert _split_think_tags("") == ("", "")
+
+
+def test_split_think_tags_multiple_blocks():
+    content = "<think>one</think>middle<think>two</think>end"
+    thought, visible = _split_think_tags(content)
+    assert "one" in thought and "two" in thought
+    assert visible == "middleend"
+
+
+def test_summarize_truncates_long_first_sentence():
+    summary = _summarize("x" * 300 + ". rest")
+    assert len(summary) <= 123
+    assert summary.endswith("...")
+
+
+def test_trace_entry_shapes():
+    t = _thinking_entry(0, "thinking hard")
+    assert t["thought"] == "thinking hard" and t["tool_name"] is None
+
+    e = _tool_entry(1, "web_search_tool", {"query": "q"}, "r" * 1000)
+    assert e["tool_name"] == "web_search_tool"
+    assert len(e["tool_result"]) == 500  # truncated for the trace