sequential-thinking 0.6.0__py3-none-any.whl

mcp_sequential_thinking/storage.py

@@ -0,0 +1,152 @@
+import threading
+from datetime import datetime
+from pathlib import Path
+
+from .logging_conf import configure_logging
+from .models import ThoughtData, ThoughtStage
+from .storage_utils import (
+    load_thoughts_from_file,
+    prepare_thoughts_for_serialization,
+    save_thoughts_to_file,
+)
+
+logger = configure_logging("sequential-thinking.storage")
+
+
+class ThoughtStorage:
+    """Storage manager for thought data."""
+
+    def __init__(self, storage_dir: str | None = None):
+        """Initialize the storage manager.
+
+        Args:
+            storage_dir: Directory to store thought data files. If None, uses a default directory.
+        """
+        if storage_dir is None:
+            # Use user's home directory by default
+            home_dir = Path.home()
+            self.storage_dir = home_dir / ".mcp_sequential_thinking"
+        else:
+            self.storage_dir = Path(storage_dir)
+
+        # Create storage directory if it doesn't exist
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+        # Default session file
+        self.current_session_file = self.storage_dir / "current_session.json"
+        self.lock_file = self.storage_dir / "current_session.lock"
+
+        # Thread safety
+        self._lock = threading.RLock()
+        self.thought_history: list[ThoughtData] = []
+
+        # Load existing session if available
+        self._load_session()
+
+    def _load_session(self) -> None:
+        """Load thought history from the current session file if it exists."""
+        with self._lock:
+            # Use the utility function to handle loading with proper error handling
+            self.thought_history = load_thoughts_from_file(
+                self.current_session_file, self.lock_file
+            )
+
+    def _save_session(self) -> None:
+        """Save the current thought history to the session file."""
+        # Use thread lock to ensure consistent data
+        with self._lock:
+            # Use utility functions to prepare and save thoughts
+            thoughts_with_ids = prepare_thoughts_for_serialization(self.thought_history)
+
+        # Save to file with proper locking
+        save_thoughts_to_file(self.current_session_file, thoughts_with_ids, self.lock_file)
+
+    def add_thought(self, thought: ThoughtData) -> None:
+        """Add a thought to the history and save the session.
+
+        Args:
+            thought: The thought data to add
+        """
+        with self._lock:
+            self.thought_history.append(thought)
+        self._save_session()
+
+    def get_all_thoughts(self) -> list[ThoughtData]:
+        """Get all thoughts in the current session.
+
+        Returns:
+            List[ThoughtData]: All thoughts in the current session
+        """
+        with self._lock:
+            # Return a copy to avoid external modification
+            return list(self.thought_history)
+
+    def get_thoughts_by_stage(self, stage: ThoughtStage) -> list[ThoughtData]:
+        """Get all thoughts in a specific stage.
+
+        Args:
+            stage: The thinking stage to filter by
+
+        Returns:
+            List[ThoughtData]: Thoughts in the specified stage
+        """
+        with self._lock:
+            return [t for t in self.thought_history if t.stage == stage]
+
+    def clear_history(self) -> None:
+        """Clear the thought history and save the empty session."""
+        with self._lock:
+            self.thought_history.clear()
+        self._save_session()
+
+    def export_session(self, file_path: str) -> None:
+        """Export the current session to a file.
+
+        Args:
+            file_path: Path to save the exported session
+        """
+        with self._lock:
+            # Use utility function to prepare thoughts for serialization
+            thoughts_with_ids = prepare_thoughts_for_serialization(self.thought_history)
+
+            # Create export-specific metadata
+            metadata = {
+                "exportedAt": datetime.now().isoformat(),
+                "metadata": {
+                    "totalThoughts": len(self.thought_history),
+                    "stages": {
+                        stage.value: len([t for t in self.thought_history if t.stage == stage])
+                        for stage in ThoughtStage
+                    },
+                },
+            }
+
+        # Convert string path to Path object for compatibility with utility
+        file_path_obj = Path(file_path)
+        lock_file = file_path_obj.with_suffix(".lock")
+
+        # Use utility function to save with proper locking
+        save_thoughts_to_file(file_path_obj, thoughts_with_ids, lock_file, metadata)
+
+    def import_session(self, file_path: str) -> None:
+        """Import a session from a file.
+
+        Args:
+            file_path: Path to the file to import
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            json.JSONDecodeError: If the file is not valid JSON
+            KeyError: If the file doesn't contain valid thought data
+        """
+        # Convert string path to Path object for compatibility with utility
+        file_path_obj = Path(file_path)
+        lock_file = file_path_obj.with_suffix(".lock")
+
+        # Use utility function to load thoughts with proper error handling
+        thoughts = load_thoughts_from_file(file_path_obj, lock_file)
+
+        with self._lock:
+            self.thought_history = thoughts
+
+        self._save_session()

mcp_sequential_thinking/storage_utils.py

@@ -0,0 +1,107 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, cast
+
+import portalocker
+
+from .logging_conf import configure_logging
+from .models import ThoughtData
+
+logger = configure_logging("sequential-thinking.storage-utils")
+
+
+def prepare_thoughts_for_serialization(thoughts: list[ThoughtData]) -> list[dict[str, Any]]:
+    """Prepare thoughts for serialization with IDs included.
+
+    Args:
+        thoughts: List of thought data objects to prepare
+
+    Returns:
+        List[Dict[str, Any]]: List of thought dictionaries with IDs
+    """
+    return [thought.to_dict(include_id=True) for thought in thoughts]
+
+
+def save_thoughts_to_file(
+    file_path: Path,
+    thoughts: list[dict[str, Any]],
+    lock_file: Path,
+    metadata: dict[str, Any] | None = None,
+) -> None:
+    """Save thoughts to a file with proper locking.
+
+    Args:
+        file_path: Path to the file to save
+        thoughts: List of thought dictionaries to save
+        lock_file: Path to the lock file
+        metadata: Optional additional metadata to include
+    """
+    data: dict[str, Any] = {"thoughts": thoughts, "lastUpdated": datetime.now().isoformat()}
+
+    # Add any additional metadata if provided
+    if metadata:
+        data.update(metadata)
+
+    # Ensure destination directories exist before acquiring the lock.
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    lock_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Use file locking to ensure thread safety when writing
+    with portalocker.Lock(lock_file, timeout=10), open(file_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+    logger.debug(f"Saved {len(thoughts)} thoughts to {file_path}")
+
+
+def load_thoughts_from_file(file_path: Path, lock_file: Path) -> list[ThoughtData]:
+    """Load thoughts from a file with proper locking.
+
+    Args:
+        file_path: Path to the file to load
+        lock_file: Path to the lock file
+
+    Returns:
+        List[ThoughtData]: Loaded thought data objects
+
+    Raises:
+        json.JSONDecodeError: If the file is not valid JSON
+        KeyError: If the file doesn't contain valid thought data
+    """
+    if not file_path.exists():
+        return []
+
+    try:
+        # Use file locking and file handling in a single with statement
+        # for cleaner resource management
+        with portalocker.Lock(lock_file, timeout=10), open(file_path, encoding="utf-8") as f:
+            data = json.load(f)
+
+        if not isinstance(data, dict):
+            return []
+
+        data_dict = cast(dict[str, Any], data)
+        raw_thoughts = data_dict.get("thoughts", [])
+        if not isinstance(raw_thoughts, list):
+            return []
+
+        thought_dicts = cast(list[Any], raw_thoughts)
+
+        # Convert data to ThoughtData objects after file is closed
+        thoughts = [
+            ThoughtData.from_dict(cast(dict[str, Any], thought_dict))
+            for thought_dict in thought_dicts
+            if isinstance(thought_dict, dict)
+        ]
+
+        logger.debug(f"Loaded {len(thoughts)} thoughts from {file_path}")
+        return thoughts
+
+    except (json.JSONDecodeError, KeyError) as e:
+        # Handle corrupted file
+        logger.error(f"Error loading from {file_path}: {e}")
+        # Create backup of corrupted file
+        backup_file = file_path.with_suffix(f".bak.{datetime.now().strftime('%Y%m%d%H%M%S')}")
+        file_path.rename(backup_file)
+        logger.info(f"Created backup of corrupted file at {backup_file}")
+        return []

mcp_sequential_thinking/utils.py

@@ -0,0 +1,71 @@
+"""Utility functions for the sequential thinking package.
+
+This module contains common utilities used across the package.
+"""
+
+import re
+from collections.abc import Callable
+from typing import Any, cast
+
+
+def to_camel_case(snake_str: str) -> str:
+    """Convert a snake_case string to camelCase.
+
+    Args:
+        snake_str: A string in snake_case format
+
+    Returns:
+        The string converted to camelCase
+    """
+    components = snake_str.split("_")
+    # Join with the first component lowercase and the rest with their first letter capitalized
+    return components[0] + "".join(x.title() for x in components[1:])
+
+
+def to_snake_case(camel_str: str) -> str:
+    """Convert a camelCase string to snake_case.
+
+    Args:
+        camel_str: A string in camelCase format
+
+    Returns:
+        The string converted to snake_case
+    """
+    # Insert underscore before uppercase letters and convert to lowercase
+    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", camel_str)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def convert_dict_keys(data: Any, converter: Callable[[str], str]) -> Any:
+    """Convert all keys in a dictionary using the provided converter function.
+
+    Args:
+        data: Dictionary with keys to convert
+        converter: Function to convert the keys (e.g. to_camel_case or to_snake_case)
+
+    Returns:
+        A new dictionary with converted keys
+    """
+    if not isinstance(data, dict):
+        return data
+
+    source = cast(dict[str, Any], data)
+    result: dict[str, Any] = {}
+    for key, value in source.items():
+        # Convert key
+        new_key = converter(key)
+
+        # If value is a dict, recursively convert its keys too
+        if isinstance(value, dict):
+            result[new_key] = convert_dict_keys(value, converter)
+        # If value is a list, check if items are dicts and convert them
+        elif isinstance(value, list):
+            items = cast(list[Any], value)
+            result[new_key] = [
+                convert_dict_keys(item, converter) if isinstance(item, dict) else item
+                for item in items
+            ]
+        else:
+            result[new_key] = value
+
+    return result