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

claude_mpm/services/socketio/handlers/connection.py

@@ -539,7 +539,7 @@ class ConnectionEventHandler(BaseEventHandler):
             if data and "timestamp" in data:
                 rtt = current_time - data["timestamp"]
                 if rtt < 10:  # Reasonable RTT
-                    self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt*1000:.1f}ms")
+                    self.logger.debug(f"🏓 Pong from {sid}, RTT: {rtt * 1000:.1f}ms")
 
     def _normalize_event(self, event_data: Dict[str, Any]) -> Dict[str, Any]:
         """Normalize event format to ensure consistency.

claude_mpm/services/socketio/handlers/git.py

@@ -745,7 +745,7 @@ class GitEventHandler(BaseEventHandler):
                                     stdout=asyncio.subprocess.PIPE,
                                     stderr=asyncio.subprocess.PIPE,
                                 )
-                                diff_output, diff_error = await diff_proc.communicate()
+                                diff_output, _ = await diff_proc.communicate()
 
                                 if diff_proc.returncode == 0:
                                     return {

claude_mpm/services/socketio/server/core.py

@@ -34,10 +34,7 @@ import contextlib
 
 from claude_mpm.services.version_service import VersionService
 
-from ....core.constants import (
-    SystemLimits,
-    TimeoutConfig,
-)
+from ....core.constants import SystemLimits, TimeoutConfig
 from ....core.logging_config import get_logger
 from ....core.unified_paths import get_project_root, get_scripts_dir
 from ...exceptions import SocketIOServerError as MPMConnectionError

claude_mpm/services/socketio/server/main.py

@@ -30,9 +30,7 @@ except ImportError:
     aiohttp = None
     web = None
 
-from ....core.constants import (
-    SystemLimits,
-)
+from ....core.constants import SystemLimits
 from ....core.logging_config import get_logger
 from ...core.interfaces.communication import SocketIOServiceInterface
 from ..handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler

claude_mpm/services/system_instructions_service.py

@@ -112,9 +112,7 @@ class SystemInstructionsService(BaseService, SystemInstructionsInterface):
                 self.agent_capabilities_service
                 and "{{AGENT_CAPABILITIES}}" in base_pm_content
             ):
-                capabilities = (
-                    self.agent_capabilities_service.generate_deployed_agent_capabilities()
-                )
+                capabilities = self.agent_capabilities_service.generate_deployed_agent_capabilities()
                 base_pm_content = base_pm_content.replace(
                     "{{AGENT_CAPABILITIES}}", capabilities
                 )

claude_mpm/services/unified/analyzer_strategies/performance_analyzer.py

@@ -527,13 +527,11 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
                         and node.iter.func.id == "range"
                         and len(node.iter.args) == 1
                     ):
-
                         if isinstance(node.iter.args[0], ast.Call):
                             if (
                                 isinstance(node.iter.args[0].func, ast.Name)
                                 and node.iter.args[0].func.id == "len"
                             ):
-
                                 results["optimizations"].append(
                                     {
                                         "type": "range_len_pattern",
@@ -562,7 +560,6 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
                         "min",
                         "max",
                     ]:
-
                         results["optimizations"].append(
                             {
                                 "type": "generator_opportunity",

claude_mpm/services/unified/analyzer_strategies/security_analyzer.py

@@ -436,7 +436,6 @@ class SecurityAnalyzerStrategy(AnalyzerStrategy):
                             and node.func.value.id == "subprocess"
                             and node.func.attr in ["run", "call", "Popen"]
                         ):
-
                             for keyword in node.keywords:
                                 if (
                                     keyword.arg == "shell"

claude_mpm/services/unified/deployment_strategies/vercel.py

@@ -17,11 +17,7 @@ from claude_mpm.core.enums import HealthStatus, OperationResult
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.unified.strategies import StrategyMetadata, StrategyPriority
 
-from .base import (
-    DeploymentContext,
-    DeploymentResult,
-    DeploymentStrategy,
-)
+from .base import DeploymentContext, DeploymentResult, DeploymentStrategy
 
 
 class VercelDeploymentStrategy(DeploymentStrategy):

claude_mpm/services/unified/unified_deployment.py

@@ -34,11 +34,7 @@ from .interfaces import (
     ServiceCapability,
     ServiceMetadata,
 )
-from .strategies import (
-    DeploymentStrategy,
-    StrategyContext,
-    get_strategy_registry,
-)
+from .strategies import DeploymentStrategy, StrategyContext, get_strategy_registry
 
 
 class UnifiedDeploymentService(IDeploymentService, IUnifiedService):

claude_mpm/services/version_control/conflict_resolution.py

@@ -458,17 +458,19 @@ class ConflictResolutionManager:
 
         for i, marker in enumerate(markers):
             if not marker.ours_content and marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Accept incoming changes (theirs)")
+                suggestions.append(
+                    f"Conflict {i + 1}: Accept incoming changes (theirs)"
+                )
             elif marker.ours_content and not marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Keep current changes (ours)")
+                suggestions.append(f"Conflict {i + 1}: Keep current changes (ours)")
             elif self._only_whitespace_differences(
                 marker.ours_content, marker.theirs_content
             ):
                 suggestions.append(
-                    f"Conflict {i+1}: Whitespace differences only - can auto-resolve"
+                    f"Conflict {i + 1}: Whitespace differences only - can auto-resolve"
                 )
             else:
-                suggestions.append(f"Conflict {i+1}: Manual merge required")
+                suggestions.append(f"Conflict {i + 1}: Manual merge required")
 
         return "; ".join(suggestions)
 

claude_mpm/services/visualization/__init__.py

@@ -6,11 +6,7 @@ This module provides visualization services for code analysis,
 including Mermaid diagram generation for various code structures.
 """
 
-from .mermaid_generator import (
-    DiagramConfig,
-    DiagramType,
-    MermaidGeneratorService,
-)
+from .mermaid_generator import DiagramConfig, DiagramType, MermaidGeneratorService
 
 __all__ = [
     "DiagramConfig",

claude_mpm/services/visualization/mermaid_generator.py

@@ -307,9 +307,8 @@ class MermaidGeneratorService(SyncBaseService):
                         import_from = imp.get("from", imp.get("module", ""))
                         if import_from:
                             import_name = self._extract_module_name(import_from)
-                            if (
-                                not config.include_external
-                                and self._is_external_module(import_name)
+                            if not config.include_external and self._is_external_module(
+                                import_name
                             ):
                                 continue
                             modules.add(import_name)

claude_mpm/skills/bundled/testing/webapp-testing/scripts/with_server.py

@@ -84,7 +84,7 @@ def main():
     try:
         # Start all servers
         for i, server in enumerate(servers):
-            print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
+            print(f"Starting server {i + 1}/{len(servers)}: {server['cmd']}")
 
             # Use shell=True to support commands with cd and &&
             process = subprocess.Popen(
@@ -121,7 +121,7 @@ def main():
             except subprocess.TimeoutExpired:
                 process.kill()
                 process.wait()
-            print(f"Server {i+1} stopped")
+            print(f"Server {i + 1} stopped")
         print("All servers stopped")
 
 

claude_mpm/skills/skills_registry.py

@@ -342,7 +342,6 @@ class SkillsRegistry(LoggerMixin):
                 query_lower in skill_name.lower()
                 or query_lower in metadata.get("description", "").lower()
             ):
-
                 results.append({"name": skill_name, **metadata})
 
         return results

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
+        """