guddion-sessions 0.1.0__tar.gz

guddion_sessions-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: guddion-sessions
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

guddion_sessions-0.1.0/README.md

@@ -0,0 +1,50 @@
+# guddion-sessions
+
+Локальный MCP-сервер, который экономит токены при переключении между
+несколькими сессиями Claude Code по одному и тому же проекту.
+
+## Зачем
+
+Длинные сессии (особенно с сабагентами) быстро съедают контекст и лимиты.
+При переключении между параллельными сессиями по одному проекту приходится
+либо пересказывать контекст заново, либо заставлять новую сессию вычитывать
+файлы/историю с нуля.
+
+`guddion-sessions` раз в N сообщений мягко напоминает занести краткий итог
+по темам (архитектура, бэкенд, фронтенд, решения, следующие шаги) в
+rolling-статус проекта. При старте новой сессии в той же рабочей директории
+этот статус автоматически подтягивается в контекст — новая сессия сразу "в
+курсе", без пересказа и без повторного чтения файлов.
+
+## Из чего состоит
+
+- **MCP-сервер** (`src/guddion_sessions/server.py`) — инструменты
+  `save_summary`, `get_status`, `get_history`, `list_topics`,
+  `get_settings`, `update_settings`.
+- **Хранилище** (`src/guddion_sessions/storage.py`) — JSON-файлы вне
+  репозиториев проектов (`~/.claude/session-mcp/storage/`), ключ — путь
+  к рабочей директории. Rolling-статус по темам + отдельный append-лог
+  истории (не подтягивается в контекст автоматически).
+- **Настройки** (`src/guddion_sessions/settings.py`) — интервал
+  напоминания, язык, дефолтные темы, вкл/выкл каждого хука. Два слоя:
+  глобальные (на все проекты) и по-проектные (переопределяют глобальные
+  для конкретного каталога).
+- **Хуки Claude Code** (`src/guddion_sessions/hooks/`) —
+  `UserPromptSubmit` (мягкое напоминание раз в N сообщений) и
+  `SessionStart` (подгрузка статуса в начале новой сессии).
+- **Авторизация** (`src/guddion_sessions/auth.py`) — все инструменты
+  MCP-сервера требуют `GUDDION_TOKEN`, проверяется один раз за время
+  жизни процесса через `mcp.guddion.ru/api/verify` (часть экосистемы
+  Guddion MCP, по образцу `guddion-web`).
+
+## Запуск
+
+```bash
+python -m venv .venv
+.venv/Scripts/python.exe -m pip install -e ".[dev]"
+.venv/Scripts/python.exe -m pytest
+```
+
+Подключается в `settings.json` Claude Code через `mcpServers` +
+`hooks.UserPromptSubmit` + `hooks.SessionStart`, с обязательной
+переменной окружения `GUDDION_TOKEN`.

guddion_sessions-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "guddion-sessions"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "fastmcp>=2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

guddion_sessions-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

guddion_sessions-0.1.0/src/guddion_sessions/__main__.py

@@ -0,0 +1,4 @@
+from .server import mcp
+
+if __name__ == "__main__":
+    mcp.run()

guddion_sessions-0.1.0/src/guddion_sessions/auth.py

@@ -0,0 +1,33 @@
+import os
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+VERIFY_URL = "https://mcp.guddion.ru/api/verify"
+
+_verified = False
+
+
+def verify_token() -> None:
+    global _verified
+    if _verified:
+        return
+
+    token = os.environ.get("GUDDION_TOKEN")
+    if not token:
+        raise RuntimeError("GUDDION_TOKEN is not set. Get one at https://mcp.guddion.ru.")
+
+    req = Request(VERIFY_URL, headers={"Authorization": f"Bearer {token}"})
+    try:
+        with urlopen(req):
+            pass
+    except HTTPError as exc:
+        raise RuntimeError(
+            f"GUDDION_TOKEN was rejected (status {exc.code}). Check your token at https://mcp.guddion.ru."
+        ) from exc
+
+    _verified = True
+
+
+def reset_auth_cache_for_tests() -> None:
+    global _verified
+    _verified = False

guddion_sessions-0.1.0/src/guddion_sessions/hooks/session_start.py

@@ -0,0 +1,45 @@
+import json
+import sys
+from pathlib import Path
+
+from .. import settings as settings_module
+from .. import storage
+
+STATUS_HEADER = {
+    "ru": "[session-mcp] Статус проекта из прошлых сессий:",
+    "en": "[session-mcp] Project status from previous sessions:",
+}
+
+
+def process(payload: dict, storage_root: Path) -> dict | None:
+    cwd = payload["cwd"]
+    effective = settings_module.get_effective_settings(storage_root, cwd)
+    if not effective["enabled_hooks"].get("session_start", True):
+        return None
+
+    status = storage.get_status(storage_root, cwd)
+    if not status:
+        return None
+
+    language = effective.get("language", "ru")
+    header = STATUS_HEADER.get(language, STATUS_HEADER["ru"])
+    lines = [header]
+    for topic in sorted(status.keys()):
+        lines.append(f"- {topic}: {status[topic]['content']}")
+    return {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": "\n".join(lines),
+        }
+    }
+
+
+def main() -> None:
+    payload = json.load(sys.stdin)
+    output = process(payload, storage.default_storage_root())
+    if output is not None:
+        print(json.dumps(output))
+
+
+if __name__ == "__main__":
+    main()

guddion_sessions-0.1.0/src/guddion_sessions/hooks/user_prompt_submit.py

@@ -0,0 +1,79 @@
+import json
+import sys
+from pathlib import Path
+
+from .. import settings as settings_module
+from .. import storage
+
+REMINDER_TEXT = {
+    "ru": (
+        "[session-mcp] Прошло {n} сообщений. Если появилось что-то важное "
+        "(архитектурное решение, договорённость, прогресс) — занеси кратко "
+        "через save_summary(topic, content). Если нечего заносить, просто "
+        "продолжай."
+    ),
+    "en": (
+        "[session-mcp] {n} messages have passed. If something important "
+        "happened (an architectural decision, an agreement, progress) — "
+        "log it briefly via save_summary(topic, content). If there's "
+        "nothing to log, just continue."
+    ),
+}
+
+
+def _state_path(state_dir: Path, session_id: str) -> Path:
+    state_dir = Path(state_dir)
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return state_dir / f"{session_id}.json"
+
+
+def _load_count(state_path: Path) -> int:
+    if not state_path.exists():
+        return 0
+    try:
+        return json.loads(state_path.read_text(encoding="utf-8")).get("count", 0)
+    except json.JSONDecodeError:
+        return 0
+
+
+def _save_count(state_path: Path, count: int) -> None:
+    state_path.write_text(json.dumps({"count": count}), encoding="utf-8")
+
+
+def process(payload: dict, state_dir: Path, storage_root: Path) -> dict | None:
+    cwd = payload["cwd"]
+    effective = settings_module.get_effective_settings(storage_root, cwd)
+    if not effective["enabled_hooks"].get("user_prompt_submit", True):
+        return None
+
+    session_id = payload["session_id"]
+    state_path = _state_path(state_dir, session_id)
+    interval = effective["reminder_interval"]
+    count = _load_count(state_path) + 1
+    if count >= interval:
+        _save_count(state_path, 0)
+        language = effective.get("language", "ru")
+        template = REMINDER_TEXT.get(language, REMINDER_TEXT["ru"])
+        return {
+            "hookSpecificOutput": {
+                "hookEventName": "UserPromptSubmit",
+                "additionalContext": template.format(n=interval),
+            }
+        }
+    _save_count(state_path, count)
+    return None
+
+
+def _default_state_dir() -> Path:
+    return Path.home() / ".claude" / "session-mcp" / "hook-state"
+
+
+def main() -> None:
+    payload = json.load(sys.stdin)
+    output = process(payload, _default_state_dir(), storage.default_storage_root())
+    if output is not None:
+        print(json.dumps(output))
+
+
+if __name__ == "__main__":
+    main()

guddion_sessions-0.1.0/src/guddion_sessions/server.py

@@ -0,0 +1,69 @@
+import os
+from pathlib import Path
+
+from fastmcp import FastMCP
+
+from . import auth, settings, storage
+
+mcp = FastMCP("guddion-sessions")
+
+
+def _cwd() -> str:
+    return os.getcwd()
+
+
+def _storage_root() -> Path:
+    return storage.default_storage_root()
+
+
+@mcp.tool
+def save_summary(topic: str, content: str) -> dict:
+    """Replace the rolling status for a topic in the current project's
+    working directory, and append it to the history log. Never store
+    secrets, tokens, or passwords here."""
+    auth.verify_token()
+    return storage.save_summary(_storage_root(), _cwd(), topic, content)
+
+
+@mcp.tool
+def get_status(topics: list[str] | None = None) -> dict:
+    """Return the current rolling status for the project in the current
+    working directory, optionally filtered to specific topics."""
+    auth.verify_token()
+    return storage.get_status(_storage_root(), _cwd(), topics)
+
+
+@mcp.tool
+def get_history(topic: str | None = None, limit: int | None = None) -> list[dict]:
+    """Return history log entries for the project in the current working
+    directory, optionally filtered by topic and limited in count."""
+    auth.verify_token()
+    return storage.get_history(_storage_root(), _cwd(), topic, limit)
+
+
+@mcp.tool
+def list_topics() -> list[str]:
+    """Return the topics that currently have a status entry for the
+    project in the current working directory."""
+    auth.verify_token()
+    return storage.list_topics(_storage_root(), _cwd())
+
+
+@mcp.tool
+def get_settings(scope: str = "effective") -> dict:
+    """Return this user's guddion-sessions settings. scope is
+    'effective' (global with project overrides applied, the default),
+    'global', or 'project'."""
+    auth.verify_token()
+    return settings.get_settings(_storage_root(), _cwd(), scope)
+
+
+@mcp.tool
+def update_settings(updates: dict, scope: str = "global") -> dict:
+    """Update this user's guddion-sessions settings and return the
+    resulting effective settings. scope is 'global' (applies to all of
+    this user's projects) or 'project' (applies only to the current
+    working directory). Ask the user which scope they want before
+    calling this."""
+    auth.verify_token()
+    return settings.update_settings(_storage_root(), _cwd(), updates, scope)

guddion_sessions-0.1.0/src/guddion_sessions/settings.py

@@ -0,0 +1,81 @@
+import json
+from pathlib import Path
+from typing import Any
+
+from . import storage
+
+DEFAULT_SETTINGS: dict[str, Any] = {
+    "reminder_interval": 10,
+    "language": "ru",
+    "default_topics": ["architecture", "backend", "frontend", "decisions", "next-steps"],
+    "enabled_hooks": {"user_prompt_submit": True, "session_start": True},
+}
+
+VALID_SCOPES = ("global", "project")
+
+
+def _global_settings_path(storage_root: Path) -> Path:
+    global_dir = Path(storage_root) / "_global"
+    global_dir.mkdir(parents=True, exist_ok=True)
+    return global_dir / "settings.json"
+
+
+def _project_settings_path(storage_root: Path, cwd: str) -> Path:
+    project_dir = storage.get_project_dir(storage_root, cwd)
+    return project_dir / "settings.json"
+
+
+def _read_settings_file(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Corrupted settings file: {path}") from exc
+
+
+def _merge(base: dict, override: dict) -> dict:
+    merged = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = {**merged[key], **value}
+        else:
+            merged[key] = value
+    return merged
+
+
+def get_effective_settings(storage_root: Path, cwd: str) -> dict:
+    effective = {
+        "reminder_interval": DEFAULT_SETTINGS["reminder_interval"],
+        "language": DEFAULT_SETTINGS["language"],
+        "default_topics": list(DEFAULT_SETTINGS["default_topics"]),
+        "enabled_hooks": dict(DEFAULT_SETTINGS["enabled_hooks"]),
+    }
+    effective = _merge(effective, _read_settings_file(_global_settings_path(storage_root)))
+    effective = _merge(effective, _read_settings_file(_project_settings_path(storage_root, cwd)))
+    return effective
+
+
+def get_settings(storage_root: Path, cwd: str, scope: str = "effective") -> dict:
+    if scope == "effective":
+        return get_effective_settings(storage_root, cwd)
+    if scope == "global":
+        return _read_settings_file(_global_settings_path(storage_root))
+    if scope == "project":
+        return _read_settings_file(_project_settings_path(storage_root, cwd))
+    raise ValueError(f"scope must be 'effective', 'global', or 'project', got {scope!r}")
+
+
+def update_settings(storage_root: Path, cwd: str, updates: dict, scope: str) -> dict:
+    if scope not in VALID_SCOPES:
+        raise ValueError(f"scope must be one of {VALID_SCOPES}, got {scope!r}")
+
+    path = (
+        _global_settings_path(storage_root)
+        if scope == "global"
+        else _project_settings_path(storage_root, cwd)
+    )
+    current = _read_settings_file(path)
+    merged = _merge(current, updates)
+    storage.atomic_write_json(path, merged)
+    return get_effective_settings(storage_root, cwd)

guddion_sessions-0.1.0/src/guddion_sessions/storage.py

@@ -0,0 +1,107 @@
+import hashlib
+import json
+import os
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def normalize_project_key(cwd: str) -> str:
+    """Stable, filesystem-safe key for a working directory path."""
+    resolved = str(Path(cwd).resolve())
+    normalized = resolved.replace("\\", "/").lower()
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:16]
+
+
+def get_project_dir(storage_root: Path, cwd: str) -> Path:
+    key = normalize_project_key(cwd)
+    project_dir = Path(storage_root) / key
+    project_dir.mkdir(parents=True, exist_ok=True)
+    return project_dir
+
+
+def atomic_write_json(path: Path, data: dict) -> None:
+    path = Path(path)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    tmp_path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    last_exc = None
+    for _ in range(5):
+        try:
+            os.replace(tmp_path, path)
+            return
+        except PermissionError as exc:
+            last_exc = exc
+            time.sleep(0.05)
+    raise last_exc
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def read_status(project_dir: Path) -> dict:
+    status_path = Path(project_dir) / "status.json"
+    if not status_path.exists():
+        return {}
+    try:
+        return json.loads(status_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Corrupted status file: {status_path}") from exc
+
+
+def append_log(project_dir: Path, topic: str, content: str) -> None:
+    log_path = Path(project_dir) / "log.jsonl"
+    entry = {"ts": _now_iso(), "topic": topic, "content": content}
+    with log_path.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+def get_history(
+    storage_root: Path, cwd: str, topic: str | None = None, limit: int | None = None
+) -> list[dict]:
+    project_dir = get_project_dir(storage_root, cwd)
+    log_path = project_dir / "log.jsonl"
+    if not log_path.exists():
+        return []
+    entries = []
+    with log_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            entry = json.loads(line)
+            if topic is None or entry["topic"] == topic:
+                entries.append(entry)
+    if limit is not None:
+        entries = entries[-limit:]
+    return entries
+
+
+def default_storage_root() -> Path:
+    override = os.environ.get("SESSION_MCP_STORAGE_DIR")
+    if override:
+        return Path(override)
+    return Path.home() / ".claude" / "session-mcp" / "storage"
+
+
+def save_summary(storage_root: Path, cwd: str, topic: str, content: str) -> dict:
+    project_dir = get_project_dir(storage_root, cwd)
+    status = read_status(project_dir)
+    entry = {"content": content, "updated_at": _now_iso()}
+    status[topic] = entry
+    atomic_write_json(project_dir / "status.json", status)
+    append_log(project_dir, topic, content)
+    return entry
+
+
+def get_status(storage_root: Path, cwd: str, topics: list[str] | None = None) -> dict:
+    project_dir = get_project_dir(storage_root, cwd)
+    status = read_status(project_dir)
+    if topics is None:
+        return status
+    return {t: status[t] for t in topics if t in status}
+
+
+def list_topics(storage_root: Path, cwd: str) -> list[str]:
+    project_dir = get_project_dir(storage_root, cwd)
+    return sorted(read_status(project_dir).keys())

guddion_sessions-0.1.0/src/guddion_sessions.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: guddion-sessions
+Version: 0.1.0
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

guddion_sessions-0.1.0/src/guddion_sessions.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+src/guddion_sessions/__init__.py
+src/guddion_sessions/__main__.py
+src/guddion_sessions/auth.py
+src/guddion_sessions/server.py
+src/guddion_sessions/settings.py
+src/guddion_sessions/storage.py
+src/guddion_sessions.egg-info/PKG-INFO
+src/guddion_sessions.egg-info/SOURCES.txt
+src/guddion_sessions.egg-info/dependency_links.txt
+src/guddion_sessions.egg-info/requires.txt
+src/guddion_sessions.egg-info/top_level.txt
+src/guddion_sessions/hooks/__init__.py
+src/guddion_sessions/hooks/session_start.py
+src/guddion_sessions/hooks/user_prompt_submit.py
+tests/test_auth.py
+tests/test_hooks_session_start.py
+tests/test_hooks_user_prompt_submit.py
+tests/test_server.py
+tests/test_settings.py
+tests/test_storage.py

guddion_sessions-0.1.0/src/guddion_sessions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

guddion_sessions-0.1.0/src/guddion_sessions.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastmcp>=2.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23

guddion_sessions-0.1.0/src/guddion_sessions.egg-info/top_level.txt

@@ -0,0 +1 @@
+guddion_sessions

guddion_sessions-0.1.0/tests/test_auth.py

@@ -0,0 +1,55 @@
+import pytest
+
+from guddion_sessions import auth
+
+
+@pytest.fixture(autouse=True)
+def _reset_auth_cache():
+    auth.reset_auth_cache_for_tests()
+    yield
+    auth.reset_auth_cache_for_tests()
+
+
+def test_verify_token_raises_when_token_not_set(monkeypatch):
+    monkeypatch.delenv("GUDDION_TOKEN", raising=False)
+    with pytest.raises(RuntimeError, match="GUDDION_TOKEN"):
+        auth.verify_token()
+
+
+def test_verify_token_raises_when_backend_rejects(monkeypatch):
+    monkeypatch.setenv("GUDDION_TOKEN", "bad-token")
+
+    def fake_urlopen(req):
+        raise auth.HTTPError(req.full_url, 401, "Unauthorized", None, None)
+
+    monkeypatch.setattr(auth, "urlopen", fake_urlopen)
+
+    with pytest.raises(RuntimeError, match="401"):
+        auth.verify_token()
+
+
+def test_verify_token_caches_successful_verification(monkeypatch):
+    monkeypatch.setenv("GUDDION_TOKEN", "good-token")
+    calls = []
+
+    class FakeResponse:
+        status = 200
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+    def fake_urlopen(req):
+        calls.append(req)
+        return FakeResponse()
+
+    monkeypatch.setattr(auth, "urlopen", fake_urlopen)
+
+    auth.verify_token()
+    auth.verify_token()
+
+    assert len(calls) == 1
+    assert calls[0].full_url == "https://mcp.guddion.ru/api/verify"
+    assert calls[0].get_header("Authorization") == "Bearer good-token"

guddion_sessions-0.1.0/tests/test_hooks_session_start.py

@@ -0,0 +1,46 @@
+from guddion_sessions import storage
+from guddion_sessions import settings as settings_module
+from guddion_sessions.hooks import session_start as ss
+
+
+def test_process_returns_none_when_no_status(tmp_path):
+    result = ss.process({"cwd": str(tmp_path / "proj")}, tmp_path)
+    assert result is None
+
+
+def test_process_returns_status_summary(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "API готов")
+    result = ss.process({"cwd": cwd}, tmp_path)
+    context = result["hookSpecificOutput"]["additionalContext"]
+    assert "backend" in context
+    assert "API готов" in context
+
+
+def test_process_includes_all_topics(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    storage.save_summary(tmp_path, cwd, "frontend", "y")
+    result = ss.process({"cwd": cwd}, tmp_path)
+    context = result["hookSpecificOutput"]["additionalContext"]
+    assert "backend" in context
+    assert "frontend" in context
+
+
+def test_process_returns_none_when_hook_disabled(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    settings_module.update_settings(
+        tmp_path, cwd, {"enabled_hooks": {"session_start": False}}, scope="project"
+    )
+    assert ss.process({"cwd": cwd}, tmp_path) is None
+
+
+def test_process_uses_english_header_when_configured(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    settings_module.update_settings(tmp_path, cwd, {"language": "en"}, scope="project")
+    result = ss.process({"cwd": cwd}, tmp_path)
+    context = result["hookSpecificOutput"]["additionalContext"]
+    assert "previous sessions" in context
+    assert "прошлых сессий" not in context

guddion_sessions-0.1.0/tests/test_hooks_user_prompt_submit.py

@@ -0,0 +1,86 @@
+from guddion_sessions import settings as settings_module
+from guddion_sessions.hooks import user_prompt_submit as ups
+
+
+def _payload(session_id, cwd):
+    return {"session_id": session_id, "cwd": cwd}
+
+
+def test_process_returns_none_before_threshold(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    payload = _payload("s1", str(tmp_path / "proj"))
+    for _ in range(9):
+        result = ups.process(payload, state_dir, storage_root)
+        assert result is None
+
+
+def test_process_returns_reminder_on_tenth_call(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    payload = _payload("s1", str(tmp_path / "proj"))
+    for _ in range(9):
+        ups.process(payload, state_dir, storage_root)
+    result = ups.process(payload, state_dir, storage_root)
+    assert result["hookSpecificOutput"]["hookEventName"] == "UserPromptSubmit"
+    assert "save_summary" in result["hookSpecificOutput"]["additionalContext"]
+
+
+def test_process_resets_after_reminder(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    payload = _payload("s1", str(tmp_path / "proj"))
+    for _ in range(10):
+        ups.process(payload, state_dir, storage_root)
+    for _ in range(9):
+        result = ups.process(payload, state_dir, storage_root)
+        assert result is None
+    result = ups.process(payload, state_dir, storage_root)
+    assert result is not None
+
+
+def test_process_tracks_sessions_independently(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    cwd = str(tmp_path / "proj")
+    for _ in range(5):
+        ups.process(_payload("s1", cwd), state_dir, storage_root)
+    result = ups.process(_payload("s2", cwd), state_dir, storage_root)
+    assert result is None
+
+
+def test_process_respects_custom_reminder_interval(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    cwd = str(tmp_path / "proj")
+    settings_module.update_settings(storage_root, cwd, {"reminder_interval": 3}, scope="project")
+    payload = _payload("s1", cwd)
+    assert ups.process(payload, state_dir, storage_root) is None
+    assert ups.process(payload, state_dir, storage_root) is None
+    result = ups.process(payload, state_dir, storage_root)
+    assert result is not None
+
+
+def test_process_returns_none_when_hook_disabled(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    cwd = str(tmp_path / "proj")
+    settings_module.update_settings(
+        storage_root, cwd, {"enabled_hooks": {"user_prompt_submit": False}}, scope="project"
+    )
+    payload = _payload("s1", cwd)
+    for _ in range(15):
+        assert ups.process(payload, state_dir, storage_root) is None
+
+
+def test_process_uses_english_reminder_text_when_configured(tmp_path):
+    state_dir = tmp_path / "state"
+    storage_root = tmp_path / "storage"
+    cwd = str(tmp_path / "proj")
+    settings_module.update_settings(
+        storage_root, cwd, {"language": "en", "reminder_interval": 1}, scope="project"
+    )
+    payload = _payload("s1", cwd)
+    result = ups.process(payload, state_dir, storage_root)
+    assert "save_summary" in result["hookSpecificOutput"]["additionalContext"]
+    assert "Прошло" not in result["hookSpecificOutput"]["additionalContext"]

guddion_sessions-0.1.0/tests/test_server.py

@@ -0,0 +1,83 @@
+import pytest
+from fastmcp import Client
+
+from guddion_sessions import auth
+from guddion_sessions.server import mcp
+
+
+@pytest.fixture
+def bypass_auth(monkeypatch):
+    monkeypatch.setattr(auth, "verify_token", lambda: None)
+
+
+async def test_save_summary_tool_roundtrip(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        result = await client.call_tool("save_summary", {"topic": "backend", "content": "готово"})
+        assert result.data["content"] == "готово"
+
+
+async def test_get_status_tool_returns_saved_topic(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        await client.call_tool("save_summary", {"topic": "backend", "content": "готово"})
+        result = await client.call_tool("get_status", {})
+        assert result.data["backend"]["content"] == "готово"
+
+
+async def test_list_topics_tool(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        await client.call_tool("save_summary", {"topic": "backend", "content": "x"})
+        result = await client.call_tool("list_topics", {})
+        assert result.data == ["backend"]
+
+
+async def test_get_history_tool(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        await client.call_tool("save_summary", {"topic": "backend", "content": "x"})
+        result = await client.call_tool("get_history", {})
+        assert len(result.data) == 1
+        assert result.data[0]["topic"] == "backend"
+
+
+async def test_get_settings_tool_returns_defaults(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        result = await client.call_tool("get_settings", {})
+        assert result.data["reminder_interval"] == 10
+
+
+async def test_update_settings_tool_persists_change(tmp_path, monkeypatch, bypass_auth):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    client = Client(mcp)
+    async with client:
+        result = await client.call_tool(
+            "update_settings", {"updates": {"reminder_interval": 5}, "scope": "global"}
+        )
+        assert result.data["reminder_interval"] == 5
+        again = await client.call_tool("get_settings", {})
+        assert again.data["reminder_interval"] == 5
+
+
+async def test_tool_call_fails_without_valid_token(tmp_path, monkeypatch):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("GUDDION_TOKEN", raising=False)
+    auth.reset_auth_cache_for_tests()
+    client = Client(mcp)
+    async with client:
+        with pytest.raises(Exception, match="GUDDION_TOKEN"):
+            await client.call_tool("get_status", {})

guddion_sessions-0.1.0/tests/test_settings.py

@@ -0,0 +1,64 @@
+import pytest
+
+from guddion_sessions import settings as settings_module
+
+
+def test_effective_settings_default_when_nothing_set(tmp_path):
+    cwd = str(tmp_path / "proj")
+    effective = settings_module.get_effective_settings(tmp_path, cwd)
+    assert effective["reminder_interval"] == 10
+    assert effective["language"] == "ru"
+    assert effective["enabled_hooks"] == {"user_prompt_submit": True, "session_start": True}
+    assert "architecture" in effective["default_topics"]
+
+
+def test_update_settings_global_scope_applies_to_all_projects(tmp_path):
+    cwd_a = str(tmp_path / "a")
+    cwd_b = str(tmp_path / "b")
+    settings_module.update_settings(tmp_path, cwd_a, {"reminder_interval": 5}, scope="global")
+    assert settings_module.get_effective_settings(tmp_path, cwd_a)["reminder_interval"] == 5
+    assert settings_module.get_effective_settings(tmp_path, cwd_b)["reminder_interval"] == 5
+
+
+def test_update_settings_project_scope_only_affects_that_project(tmp_path):
+    cwd_a = str(tmp_path / "a")
+    cwd_b = str(tmp_path / "b")
+    settings_module.update_settings(tmp_path, cwd_a, {"reminder_interval": 3}, scope="project")
+    assert settings_module.get_effective_settings(tmp_path, cwd_a)["reminder_interval"] == 3
+    assert settings_module.get_effective_settings(tmp_path, cwd_b)["reminder_interval"] == 10
+
+
+def test_project_scope_overrides_global_scope(tmp_path):
+    cwd = str(tmp_path / "a")
+    settings_module.update_settings(tmp_path, cwd, {"reminder_interval": 5}, scope="global")
+    settings_module.update_settings(tmp_path, cwd, {"reminder_interval": 3}, scope="project")
+    assert settings_module.get_effective_settings(tmp_path, cwd)["reminder_interval"] == 3
+
+
+def test_update_settings_merges_nested_enabled_hooks(tmp_path):
+    cwd = str(tmp_path / "a")
+    settings_module.update_settings(
+        tmp_path, cwd, {"enabled_hooks": {"session_start": False}}, scope="project"
+    )
+    effective = settings_module.get_effective_settings(tmp_path, cwd)
+    assert effective["enabled_hooks"] == {"user_prompt_submit": True, "session_start": False}
+
+
+def test_update_settings_invalid_scope_raises(tmp_path):
+    cwd = str(tmp_path / "a")
+    with pytest.raises(ValueError):
+        settings_module.update_settings(tmp_path, cwd, {"reminder_interval": 5}, scope="bogus")
+
+
+def test_get_settings_scope_global_and_project_are_isolated(tmp_path):
+    cwd = str(tmp_path / "a")
+    settings_module.update_settings(tmp_path, cwd, {"reminder_interval": 5}, scope="global")
+    settings_module.update_settings(tmp_path, cwd, {"reminder_interval": 3}, scope="project")
+    assert settings_module.get_settings(tmp_path, cwd, scope="global")["reminder_interval"] == 5
+    assert settings_module.get_settings(tmp_path, cwd, scope="project")["reminder_interval"] == 3
+
+
+def test_get_settings_invalid_scope_raises(tmp_path):
+    cwd = str(tmp_path / "a")
+    with pytest.raises(ValueError):
+        settings_module.get_settings(tmp_path, cwd, scope="bogus")

guddion_sessions-0.1.0/tests/test_storage.py

@@ -0,0 +1,166 @@
+from pathlib import Path
+
+from guddion_sessions import storage
+
+
+def test_normalize_project_key_same_path_different_case():
+    key_lower = storage.normalize_project_key("d:/guddion/projects/session-mcp")
+    key_upper = storage.normalize_project_key("D:\\Guddion\\Projects\\session-mcp")
+    assert key_lower == key_upper
+
+
+def test_normalize_project_key_different_paths_differ():
+    key_a = storage.normalize_project_key("D:/a")
+    key_b = storage.normalize_project_key("D:/b")
+    assert key_a != key_b
+
+
+def test_get_project_dir_creates_directory(tmp_path):
+    project_dir = storage.get_project_dir(tmp_path, str(tmp_path / "myproject"))
+    assert project_dir.exists()
+    assert project_dir.parent == tmp_path
+
+
+def test_get_project_dir_stable_across_calls(tmp_path):
+    cwd = str(tmp_path / "myproject")
+    first = storage.get_project_dir(tmp_path, cwd)
+    second = storage.get_project_dir(tmp_path, cwd)
+    assert first == second
+
+
+import json
+
+
+def test_atomic_write_json_writes_valid_file(tmp_path):
+    target = tmp_path / "status.json"
+    storage.atomic_write_json(target, {"a": 1})
+    assert json.loads(target.read_text(encoding="utf-8")) == {"a": 1}
+
+
+def test_atomic_write_json_no_leftover_tmp_file(tmp_path):
+    target = tmp_path / "status.json"
+    storage.atomic_write_json(target, {"a": 1})
+    assert list(tmp_path.iterdir()) == [target]
+
+
+def test_atomic_write_json_retries_on_permission_error(tmp_path, monkeypatch):
+    target = tmp_path / "status.json"
+    real_replace = storage.os.replace
+    calls = {"count": 0}
+
+    def flaky_replace(src, dst):
+        calls["count"] += 1
+        if calls["count"] < 3:
+            raise PermissionError("locked")
+        real_replace(src, dst)
+
+    monkeypatch.setattr(storage.os, "replace", flaky_replace)
+    monkeypatch.setattr(storage.time, "sleep", lambda seconds: None)
+
+    storage.atomic_write_json(target, {"a": 1})
+
+    assert calls["count"] == 3
+    assert json.loads(target.read_text(encoding="utf-8")) == {"a": 1}
+
+
+def test_atomic_write_json_raises_after_exhausting_retries(tmp_path, monkeypatch):
+    target = tmp_path / "status.json"
+
+    def always_fails(src, dst):
+        raise PermissionError("locked")
+
+    monkeypatch.setattr(storage.os, "replace", always_fails)
+    monkeypatch.setattr(storage.time, "sleep", lambda seconds: None)
+
+    import pytest
+    with pytest.raises(PermissionError):
+        storage.atomic_write_json(target, {"a": 1})
+
+
+import pytest as _pytest
+
+
+def test_read_status_missing_file_returns_empty_dict(tmp_path):
+    assert storage.read_status(tmp_path) == {}
+
+
+def test_read_status_corrupted_file_raises(tmp_path):
+    (tmp_path / "status.json").write_text("{not valid json", encoding="utf-8")
+    with _pytest.raises(ValueError):
+        storage.read_status(tmp_path)
+
+
+def test_save_summary_creates_topic_with_timestamp(tmp_path):
+    entry = storage.save_summary(tmp_path, str(tmp_path / "proj"), "backend", "API готов")
+    assert entry["content"] == "API готов"
+    assert "updated_at" in entry
+
+
+def test_save_summary_replaces_not_appends(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "первая версия")
+    storage.save_summary(tmp_path, cwd, "backend", "вторая версия")
+    status = storage.get_status(tmp_path, cwd)
+    assert status["backend"]["content"] == "вторая версия"
+
+
+def test_get_status_filters_by_topics(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    storage.save_summary(tmp_path, cwd, "frontend", "y")
+    status = storage.get_status(tmp_path, cwd, topics=["backend"])
+    assert list(status.keys()) == ["backend"]
+
+
+def test_get_status_missing_project_returns_empty(tmp_path):
+    assert storage.get_status(tmp_path, str(tmp_path / "unknown")) == {}
+
+
+def test_list_topics_sorted(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "frontend", "y")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    assert storage.list_topics(tmp_path, cwd) == ["backend", "frontend"]
+
+
+def test_save_summary_appends_log_entry(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    history = storage.get_history(tmp_path, cwd)
+    assert len(history) == 1
+    assert history[0]["topic"] == "backend"
+    assert history[0]["content"] == "x"
+    assert "ts" in history[0]
+
+
+def test_get_history_filters_by_topic(tmp_path):
+    cwd = str(tmp_path / "proj")
+    storage.save_summary(tmp_path, cwd, "backend", "x")
+    storage.save_summary(tmp_path, cwd, "frontend", "y")
+    history = storage.get_history(tmp_path, cwd, topic="frontend")
+    assert len(history) == 1
+    assert history[0]["topic"] == "frontend"
+
+
+def test_get_history_respects_limit(tmp_path):
+    cwd = str(tmp_path / "proj")
+    for i in range(5):
+        storage.save_summary(tmp_path, cwd, "backend", f"version {i}")
+    history = storage.get_history(tmp_path, cwd, limit=2)
+    assert len(history) == 2
+    assert history[-1]["content"] == "version 4"
+
+
+def test_get_history_missing_log_returns_empty(tmp_path):
+    assert storage.get_history(tmp_path, str(tmp_path / "unknown")) == []
+
+
+def test_default_storage_root_uses_env_override(monkeypatch, tmp_path):
+    monkeypatch.setenv("SESSION_MCP_STORAGE_DIR", str(tmp_path))
+    assert storage.default_storage_root() == tmp_path
+
+
+def test_default_storage_root_falls_back_to_home(monkeypatch):
+    monkeypatch.delenv("SESSION_MCP_STORAGE_DIR", raising=False)
+    expected = Path.home() / ".claude" / "session-mcp" / "storage"
+    assert storage.default_storage_root() == expected