claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/storage/state_storage.py

@@ -16,7 +16,6 @@ import fcntl
 import gzip
 import hashlib
 import json
-import logging
 import os
 import pickle
 import platform
@@ -25,6 +24,10 @@ import time
 from contextlib import contextmanager, suppress
 from typing import Any, Dict, Optional, Tuple, Union
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class StateStorage:
     """Reliable state storage with atomic operations."""
@@ -38,9 +41,6 @@ class StateStorage:
         self.storage_dir = storage_dir or Path.home() / ".claude-mpm" / "storage"
         self.storage_dir.mkdir(parents=True, exist_ok=True)
 
-        # Logging
-        self.logger = logging.getLogger(__name__)
-
         # File locking support (Unix-like systems)
         self.supports_locking = platform.system() != "Windows"
 
@@ -79,14 +79,14 @@ class StateStorage:
                 with gzip.open(file_path, "wt", encoding="utf-8") as f:
                     json.dump(data, f, indent=2, default=str)
             else:
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     json.dump(data, f, indent=2, default=str)
 
             self.write_count += 1
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write JSON to {file_path}: {e}")
+            logger.error(f"Failed to write JSON to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -106,7 +106,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -118,14 +118,14 @@ class StateStorage:
                     with gzip.open(file_path, "rt", encoding="utf-8") as f:
                         data = json.load(f)
                 else:
-                    with open(file_path) as f:
+                    with file_path.open() as f:
                         data = json.load(f)
 
             self.read_count += 1
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read JSON from {file_path}: {e}")
+            logger.error(f"Failed to read JSON from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -159,14 +159,14 @@ class StateStorage:
                 with gzip.open(file_path, "wb") as f:
                     pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
             else:
-                with open(file_path, "wb") as f:
+                with file_path.open("wb") as f:
                     pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
 
             self.write_count += 1
             return True
 
         except Exception as e:
-            self.logger.error(f"Failed to write pickle to {file_path}: {e}")
+            logger.error(f"Failed to write pickle to {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -186,7 +186,7 @@ class StateStorage:
             file_path = Path(file_path)
 
             if not file_path.exists():
-                self.logger.debug(f"File not found: {file_path}")
+                logger.debug(f"File not found: {file_path}")
                 return None
 
             # Auto-detect compression
@@ -198,14 +198,14 @@ class StateStorage:
                     with gzip.open(file_path, "rb") as f:
                         data = pickle.load(f)
                 else:
-                    with open(file_path, "rb") as f:
+                    with file_path.open("rb") as f:
                         data = pickle.load(f)
 
             self.read_count += 1
             return data
 
         except Exception as e:
-            self.logger.error(f"Failed to read pickle from {file_path}: {e}")
+            logger.error(f"Failed to read pickle from {file_path}: {e}")
             self.error_count += 1
             return None
 
@@ -262,16 +262,16 @@ class StateStorage:
                 Path(temp_path).replace(file_path)
 
                 self.write_count += 1
-                self.logger.debug(f"Atomic write successful: {file_path}")
+                logger.debug(f"Atomic write successful: {file_path}")
                 return True
 
             finally:
                 # Clean up temp file if it still exists
                 if Path(temp_path).exists():
-                    os.unlink(temp_path)
+                    Path(temp_path).unlink()
 
         except Exception as e:
-            self.logger.error(f"Atomic write failed for {file_path}: {e}")
+            logger.error(f"Atomic write failed for {file_path}: {e}")
             self.error_count += 1
             return False
 
@@ -288,14 +288,14 @@ class StateStorage:
         """
         if not self.supports_locking:
             # No locking on Windows
-            with open(file_path, mode) as f:
+            with Path(file_path).open(mode) as f:
                 yield f
             return
 
         # Unix-like systems with fcntl
         f = None
         try:
-            f = open(file_path, mode)
+            f = Path(file_path).open(mode)
 
             # Try to acquire lock (non-blocking)
             max_attempts = 50
@@ -327,7 +327,7 @@ class StateStorage:
 
             # Calculate checksum
             hasher = hashlib.sha256()
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 for chunk in iter(lambda: f.read(4096), b""):
                     hasher.update(chunk)
 
@@ -335,11 +335,11 @@ class StateStorage:
 
             # Write checksum file
             checksum_path = file_path.with_suffix(file_path.suffix + ".sha256")
-            with open(checksum_path, "w") as f:
+            with checksum_path.open("w") as f:
                 f.write(checksum)
 
         except Exception as e:
-            self.logger.warning(f"Could not add checksum: {e}")
+            logger.warning(f"Could not add checksum: {e}")
 
     def verify_checksum(self, file_path: Union[str, Path]) -> bool:
         """Verify file checksum for integrity.
@@ -358,25 +358,25 @@ class StateStorage:
                 return True  # No checksum to verify
 
             # Read expected checksum
-            with open(checksum_path) as f:
+            with checksum_path.open() as f:
                 expected = f.read().strip()
 
             # Calculate actual checksum
             hasher = hashlib.sha256()
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 for chunk in iter(lambda: f.read(4096), b""):
                     hasher.update(chunk)
 
             actual = hasher.hexdigest()
 
             if actual != expected:
-                self.logger.error(f"Checksum mismatch for {file_path}")
+                logger.error(f"Checksum mismatch for {file_path}")
                 return False
 
             return True
 
         except Exception as e:
-            self.logger.warning(f"Could not verify checksum: {e}")
+            logger.warning(f"Could not verify checksum: {e}")
             return True  # Assume valid if can't verify
 
     def cleanup_temp_files(self) -> int:
@@ -396,8 +396,8 @@ class StateStorage:
                     if age > 3600:
                         temp_file.unlink()
                         cleaned += 1
-                        self.logger.debug(f"Cleaned up temp file: {temp_file}")
-                except:
+                        logger.debug(f"Cleaned up temp file: {temp_file}")
+                except Exception:
                     pass
 
             # Clean up orphaned checksum files
@@ -408,12 +408,12 @@ class StateStorage:
                     cleaned += 1
 
             if cleaned > 0:
-                self.logger.info(f"Cleaned up {cleaned} temporary files")
+                logger.info(f"Cleaned up {cleaned} temporary files")
 
             return cleaned
 
         except Exception as e:
-            self.logger.error(f"Error cleaning up temp files: {e}")
+            logger.error(f"Error cleaning up temp files: {e}")
             return 0
 
     def get_storage_info(self) -> Dict[str, Any]:
@@ -447,7 +447,7 @@ class StateStorage:
             }
 
         except Exception as e:
-            self.logger.error(f"Error getting storage info: {e}")
+            logger.error(f"Error getting storage info: {e}")
             return {"storage_directory": str(self.storage_dir), "error": str(e)}
 
 

claude_mpm/templates/questions/__init__.py

@@ -0,0 +1,38 @@
+"""Structured question templates for common PM workflows.
+
+This package provides reusable question templates that PM agents can use to gather
+user input in a structured way. Templates are pre-configured QuestionSet objects
+that can be customized based on context.
+
+Available Templates:
+- PR Strategy: Questions about PR workflow, draft preferences, auto-merge
+- Project Initialization: Questions about project type, language, frameworks
+- Ticket Management: Questions about ticket prioritization and scope
+
+Example Usage:
+    >>> from claude_mpm.templates.questions.pr_strategy import PRWorkflowTemplate
+    >>> template = PRWorkflowTemplate(num_tickets=3)
+    >>> question_set = template.build()
+    >>> params = question_set.to_ask_user_question_params()
+"""
+
+from claude_mpm.templates.questions.base import ConditionalTemplate, QuestionTemplate
+from claude_mpm.templates.questions.pr_strategy import PRWorkflowTemplate
+from claude_mpm.templates.questions.project_init import (
+    DevelopmentWorkflowTemplate,
+    ProjectTypeTemplate,
+)
+from claude_mpm.templates.questions.ticket_mgmt import (
+    TicketPrioritizationTemplate,
+    TicketScopeTemplate,
+)
+
+__all__ = [
+    "ConditionalTemplate",
+    "DevelopmentWorkflowTemplate",
+    "PRWorkflowTemplate",
+    "ProjectTypeTemplate",
+    "QuestionTemplate",
+    "TicketPrioritizationTemplate",
+    "TicketScopeTemplate",
+]

claude_mpm/templates/questions/base.py

@@ -0,0 +1,193 @@
+"""Base classes for structured question templates.
+
+This module provides abstract base classes for creating reusable question templates.
+Templates encapsulate common question patterns and can be context-aware.
+
+Design Patterns:
+- Template Method: Define question structure, subclasses provide details
+- Strategy: Different templates for different workflows
+- Factory: Templates build QuestionSet objects
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from claude_mpm.utils.structured_questions import QuestionSet
+
+
+class QuestionTemplate(ABC):
+    """Abstract base class for question templates.
+
+    Subclasses should implement the build() method to construct a QuestionSet
+    based on template-specific logic and any provided context.
+
+    Example:
+        >>> class MyTemplate(QuestionTemplate):
+        ...     def build(self) -> QuestionSet:
+        ...         question = QuestionBuilder().ask("...").build()
+        ...         return QuestionSet([question])
+    """
+
+    @abstractmethod
+    def build(self) -> QuestionSet:
+        """Build and return a QuestionSet.
+
+        Returns:
+            QuestionSet ready for use with AskUserQuestion tool
+
+        Raises:
+            QuestionValidationError: If question construction fails
+        """
+
+    def to_params(self) -> dict[str, Any]:
+        """Build question set and convert to AskUserQuestion parameters.
+
+        Returns:
+            Dictionary suitable for AskUserQuestion tool
+
+        Raises:
+            QuestionValidationError: If question construction fails
+        """
+        return self.build().to_ask_user_question_params()
+
+
+class ConditionalTemplate(QuestionTemplate):
+    """Template that adjusts questions based on context.
+
+    This base class provides infrastructure for templates that need to vary
+    their questions based on runtime context (e.g., number of tickets,
+    project type, etc.).
+
+    Attributes:
+        context: Dictionary of context values that affect question selection
+    """
+
+    def __init__(self, **context: Any) -> None:
+        """Initialize with context values.
+
+        Args:
+            **context: Arbitrary context values used to determine questions
+        """
+        self.context = context
+
+    def get_context(self, key: str, default: Any = None) -> Any:
+        """Get a context value.
+
+        Args:
+            key: Context key to retrieve
+            default: Default value if key not found
+
+        Returns:
+            Context value or default
+        """
+        return self.context.get(key, default)
+
+    def has_context(self, key: str) -> bool:
+        """Check if context key exists.
+
+        Args:
+            key: Context key to check
+
+        Returns:
+            True if key exists in context, False otherwise
+        """
+        return key in self.context
+
+    def should_include_question(self, question_id: str) -> bool:
+        """Determine if a question should be included based on context.
+
+        Subclasses can override this to implement conditional logic.
+
+        Args:
+            question_id: Identifier for the question being considered
+
+        Returns:
+            True if question should be included, False otherwise
+        """
+        return True
+
+    @abstractmethod
+    def build(self) -> QuestionSet:
+        """Build QuestionSet based on context.
+
+        Subclasses must implement this to create context-aware questions.
+
+        Returns:
+            QuestionSet with questions appropriate for the context
+        """
+
+
+class MultiStepTemplate(QuestionTemplate):
+    """Template for multi-step question workflows.
+
+    Some workflows require multiple rounds of questions, where later questions
+    depend on answers to earlier ones. This base class provides infrastructure
+    for such workflows.
+
+    Note: Initial implementation focuses on single-step templates. This class
+    is provided for future extensibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize multi-step template."""
+        self._current_step = 0
+        self._answers: dict[str, Any] = {}
+
+    def set_answers(self, step: int, answers: dict[str, Any]) -> None:
+        """Record answers from a previous step.
+
+        Args:
+            step: Step number (0-indexed)
+            answers: Parsed answers from ResponseParser
+        """
+        self._answers[str(step)] = answers
+
+    def get_answers(self, step: int) -> dict[str, Any] | None:
+        """Get answers from a previous step.
+
+        Args:
+            step: Step number (0-indexed)
+
+        Returns:
+            Answers dictionary or None if step not completed
+        """
+        return self._answers.get(str(step))
+
+    @abstractmethod
+    def build_step(self, step: int) -> QuestionSet:
+        """Build questions for a specific step.
+
+        Args:
+            step: Step number (0-indexed)
+
+        Returns:
+            QuestionSet for the specified step
+        """
+
+    def build(self) -> QuestionSet:
+        """Build questions for the current step.
+
+        Returns:
+            QuestionSet for current step
+        """
+        return self.build_step(self._current_step)
+
+    def advance_step(self) -> None:
+        """Move to the next step."""
+        self._current_step += 1
+
+    @property
+    def current_step(self) -> int:
+        """Get current step number."""
+        return self._current_step
+
+    @abstractmethod
+    def is_complete(self) -> bool:
+        """Check if all steps are complete.
+
+        Returns:
+            True if workflow is complete, False otherwise
+        """