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

claude_mpm/services/mcp_gateway/utils/package_version_checker.py

@@ -1,160 +0,0 @@
-"""
-Package Version Checker
-=======================
-
-Checks PyPI packages for updates with caching and timeout support.
-Provides non-blocking version checking for MCP tools like kuzu-memory.
-"""
-
-import asyncio
-import json
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import aiohttp
-from packaging import version
-
-from ....core.logger import get_logger
-
-
-class PackageVersionChecker:
-    """
-    Check PyPI packages for updates with caching and timeout.
-
-    WHY: Automatically detect when newer versions of critical packages
-    (like kuzu-memory) are available to help users stay up-to-date.
-
-    DESIGN DECISIONS:
-    - Cache results to avoid excessive PyPI API calls
-    - Non-blocking with timeout to prevent startup delays
-    - Graceful failure handling (never block system operation)
-    """
-
-    CACHE_DIR = Path.home() / ".cache" / "claude-mpm" / "version-checks"
-    DEFAULT_CACHE_TTL = 86400  # 24 hours
-    PYPI_TIMEOUT = 5  # seconds
-
-    def __init__(self):
-        """Initialize the version checker with cache directory."""
-        self.logger = get_logger("PackageVersionChecker")
-        self.cache_dir = self.CACHE_DIR
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-    async def check_for_update(
-        self, package_name: str, current_version: str, cache_ttl: Optional[int] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Check if a package has updates available.
-
-        Args:
-            package_name: Name of the package on PyPI
-            current_version: Currently installed version
-            cache_ttl: Cache time-to-live in seconds (optional)
-
-        Returns:
-            Dict with update information or None if check fails:
-            {
-                "current": "1.0.0",
-                "latest": "1.1.0",
-                "update_available": True,
-                "checked_at": "2025-01-29T12:00:00"
-            }
-        """
-        cache_ttl = cache_ttl or self.DEFAULT_CACHE_TTL
-
-        # Check cache first
-        cache_file = self.cache_dir / f"{package_name}.json"
-        cached = self._read_cache(cache_file, cache_ttl)
-        if cached:
-            # Update current version in cached data
-            cached["current"] = current_version
-            cached["update_available"] = version.parse(
-                cached["latest"]
-            ) > version.parse(current_version)
-            return cached
-
-        # Fetch from PyPI with timeout
-        try:
-            latest = await self._fetch_pypi_version(package_name)
-            if latest:
-                result = {
-                    "current": current_version,
-                    "latest": latest,
-                    "update_available": version.parse(latest)
-                    > version.parse(current_version),
-                    "checked_at": datetime.now(timezone.utc).isoformat(),
-                }
-                self._write_cache(cache_file, result)
-                return result
-        except Exception as e:
-            self.logger.debug(f"Version check failed for {package_name}: {e}")
-
-        return None
-
-    async def _fetch_pypi_version(self, package_name: str) -> Optional[str]:
-        """
-        Fetch the latest version from PyPI.
-
-        Args:
-            package_name: Package name to query
-
-        Returns:
-            Latest version string or None if fetch fails
-        """
-        url = f"https://pypi.org/pypi/{package_name}/json"
-
-        try:
-            timeout = aiohttp.ClientTimeout(total=self.PYPI_TIMEOUT)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return data["info"]["version"]
-        except asyncio.TimeoutError:
-            self.logger.debug(f"PyPI request timed out for {package_name}")
-        except Exception as e:
-            self.logger.debug(f"PyPI request failed: {e}")
-
-        return None
-
-    def _read_cache(self, cache_file: Path, ttl: int) -> Optional[Dict[str, Any]]:
-        """
-        Read from cache if valid.
-
-        Args:
-            cache_file: Path to cache file
-            ttl: Time-to-live in seconds
-
-        Returns:
-            Cached data if valid, None otherwise
-        """
-        if not cache_file.exists():
-            return None
-
-        try:
-            with cache_file.open() as f:
-                data = json.load(f)
-
-            # Check TTL
-            checked_at = datetime.fromisoformat(data["checked_at"])
-            if datetime.now(timezone.utc) - checked_at < timedelta(seconds=ttl):
-                return data
-        except Exception as e:
-            self.logger.debug(f"Cache read error: {e}")
-
-        return None
-
-    def _write_cache(self, cache_file: Path, data: Dict[str, Any]) -> None:
-        """
-        Write data to cache file.
-
-        Args:
-            cache_file: Path to cache file
-            data: Data to cache
-        """
-        try:
-            with cache_file.open("w") as f:
-                json.dump(data, f, indent=2)
-        except Exception as e:
-            self.logger.debug(f"Cache write failed: {e}")

claude_mpm/services/mcp_gateway/utils/update_preferences.py

@@ -1,170 +0,0 @@
-"""
-Update Preferences Manager
-===========================
-
-Manages user preferences for package update checking.
-Allows users to skip specific versions or disable update checks entirely.
-"""
-
-import json
-from pathlib import Path
-from typing import Any, Dict
-
-
-class UpdatePreferences:
-    """
-    Manage update checking preferences.
-
-    WHY: Respect user preferences about update notifications to avoid
-    annoying users who want to stay on specific versions or disable checks.
-
-    DESIGN DECISIONS:
-    - Store preferences in user's home directory
-    - Simple JSON format for easy manual editing
-    - Per-package preferences for granular control
-    """
-
-    PREFS_FILE = Path.home() / ".claude-mpm" / "mcp_updates.json"
-
-    @classmethod
-    def load(cls) -> Dict[str, Any]:
-        """
-        Load preferences from disk.
-
-        Returns:
-            Dictionary of preferences, empty dict if file doesn't exist
-        """
-        if cls.PREFS_FILE.exists():
-            try:
-                with cls.PREFS_FILE.open() as f:
-                    return json.load(f)
-            except (OSError, json.JSONDecodeError):
-                # Return empty dict if file is corrupted or unreadable
-                pass
-        return {}
-
-    @classmethod
-    def save(cls, prefs: Dict[str, Any]) -> None:
-        """
-        Save preferences to disk.
-
-        Args:
-            prefs: Preferences dictionary to save
-        """
-        cls.PREFS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            with cls.PREFS_FILE.open("w") as f:
-                json.dump(prefs, f, indent=2)
-        except OSError:
-            # Silently fail if we can't write preferences
-            pass
-
-    @classmethod
-    def should_check_package(cls, package: str) -> bool:
-        """
-        Check if updates should be checked for a specific package.
-
-        Args:
-            package: Package name to check
-
-        Returns:
-            True if updates should be checked, False otherwise
-        """
-        prefs = cls.load()
-
-        # Global preference takes precedence
-        if not prefs.get("global_check_enabled", True):
-            return False
-
-        # Package-specific preference
-        pkg_prefs = prefs.get("packages", {}).get(package, {})
-        return pkg_prefs.get("check_enabled", True)
-
-    @classmethod
-    def should_skip_version(cls, package: str, version: str) -> bool:
-        """
-        Check if a specific version should be skipped for a package.
-
-        Args:
-            package: Package name
-            version: Version to check
-
-        Returns:
-            True if this version should be skipped, False otherwise
-        """
-        prefs = cls.load()
-        pkg_prefs = prefs.get("packages", {}).get(package, {})
-        skip_version = pkg_prefs.get("skip_version")
-        return skip_version == version
-
-    @classmethod
-    def set_skip_version(cls, package: str, version: str) -> None:
-        """
-        Remember to skip a specific version for a package.
-
-        Args:
-            package: Package name
-            version: Version to skip
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["skip_version"] = version
-        cls.save(prefs)
-
-    @classmethod
-    def disable_package_checks(cls, package: str) -> None:
-        """
-        Disable update checks for a specific package.
-
-        Args:
-            package: Package name to disable checks for
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["check_enabled"] = False
-        cls.save(prefs)
-
-    @classmethod
-    def enable_package_checks(cls, package: str) -> None:
-        """
-        Enable update checks for a specific package.
-
-        Args:
-            package: Package name to enable checks for
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["check_enabled"] = True
-        cls.save(prefs)
-
-    @classmethod
-    def disable_all_checks(cls) -> None:
-        """Disable all update checks globally."""
-        prefs = cls.load()
-        prefs["global_check_enabled"] = False
-        cls.save(prefs)
-
-    @classmethod
-    def enable_all_checks(cls) -> None:
-        """Enable all update checks globally."""
-        prefs = cls.load()
-        prefs["global_check_enabled"] = True
-        cls.save(prefs)

claude_mpm/skills/bundled/collaboration/brainstorming/SKILL.md

@@ -1,79 +0,0 @@
----
-name: Brainstorming Ideas Into Designs
-description: Interactive idea refinement using Socratic method to develop fully-formed designs
-when_to_use: when partner describes any feature or project idea, before writing code or implementation plans
-version: 2.2.0
-progressive_disclosure:
-  level: 1
-  references: []
-  note: Already optimal at 75 lines - intentionally compact, no references needed
----
-
-# Brainstorming Ideas Into Designs
-
-## Overview
-
-Transform rough ideas into fully-formed designs through structured questioning and alternative exploration.
-
-**Core principle:** Ask questions to understand, explore alternatives, present design incrementally for validation.
-
-**Announce at start:** "I'm using the Brainstorming skill to refine your idea into a design."
-
-## The Process
-
-### Phase 1: Understanding
-- Check current project state in working directory
-- Ask ONE question at a time to refine the idea
-- Prefer multiple choice when possible
-- Gather: Purpose, constraints, success criteria
-
-### Phase 2: Exploration
-- Propose 2-3 different approaches
-- For each: Core architecture, trade-offs, complexity assessment
-- Ask your human partner which approach resonates
-
-### Phase 3: Design Presentation
-- Present in 200-300 word sections
-- Cover: Architecture, components, data flow, error handling, testing
-- Ask after each section: "Does this look right so far?"
-
-### Phase 4: Worktree Setup (for implementation)
-When design is approved and implementation will follow:
-- Announce: "I'm using the Using Git Worktrees skill to set up an isolated workspace."
-- Switch to skills/collaboration/using-git-worktrees
-- Follow that skill's process for directory selection, safety verification, and setup
-- Return here when worktree ready
-
-### Phase 5: Planning Handoff
-Ask: "Ready to create the implementation plan?"
-
-When your human partner confirms (any affirmative response):
-- Announce: "I'm using the Writing Plans skill to create the implementation plan."
-- Switch to skills/collaboration/writing-plans skill
-- Create detailed plan in the worktree
-
-## When to Revisit Earlier Phases
-
-**You can and should go backward when:**
-- Partner reveals new constraint during Phase 2 or 3 → Return to Phase 1 to understand it
-- Validation shows fundamental gap in requirements → Return to Phase 1
-- Partner questions approach during Phase 3 → Return to Phase 2 to explore alternatives
-- Something doesn't make sense → Go back and clarify
-
-**Don't force forward linearly** when going backward would give better results.
-
-## Related Skills
-
-**During exploration:**
-- When approaches have genuine trade-offs: skills/architecture/preserving-productive-tensions
-
-**Before proposing changes to existing code:**
-- Understand why it exists: skills/research/tracing-knowledge-lineages
-
-## Remember
-- One question per message during Phase 1
-- Apply YAGNI ruthlessly
-- Explore 2-3 alternatives before settling
-- Present incrementally, validate as you go
-- Go backward when needed - flexibility > rigid progression
-- Announce skill usage at start

claude_mpm/skills/bundled/collaboration/dispatching-parallel-agents/SKILL.md

@@ -1,178 +0,0 @@
----
-name: Dispatching Parallel Agents
-description: Use multiple Claude agents to investigate and fix independent problems concurrently
-when_to_use: when facing 3+ independent failures that can be investigated without shared state or dependencies
-version: 2.0.0
-progressive_disclosure:
-  entry_point:
-    summary: "Dispatch one agent per independent problem domain to solve multiple unrelated failures concurrently"
-    when_to_use: "When you have 3+ independent failures in different test files/subsystems with no shared state or dependencies"
-    quick_start: "1. Identify independent domains 2. Create focused agent tasks 3. Dispatch in parallel 4. Review summaries 5. Verify no conflicts and integrate"
-  references:
-    - coordination-patterns.md
-    - agent-prompts.md
-    - examples.md
-    - troubleshooting.md
----
-
-# Dispatching Parallel Agents
-
-## Overview
-
-When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.
-
-**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
-
-## When to Use This Skill
-
-Activate this skill when you're facing:
-- **3+ test files failing** with different root causes
-- **Multiple subsystems broken** independently
-- **Each problem is self-contained** - can be understood without context from others
-- **No shared state** between investigations
-- **Clear domain boundaries** - fixing one won't affect others
-
-**Don't use when:**
-- Failures are related (fix one might fix others)
-- Need to understand full system state first
-- Agents would interfere with each other (editing same files)
-- Exploratory debugging (don't know what's broken yet)
-
-## The Iron Law
-
-```
-One agent, one problem domain, one clear outcome.
-Never overlap scopes. Never share state. Always integrate consciously.
-```
-
-## Core Principles
-
-### Independence is Key
-Problems must be truly independent - no shared files, no related root causes, no dependencies between fixes.
-
-### Focus Over Breadth
-Each agent gets narrow scope: one test file, one subsystem, one clear goal. Broad tasks lead to confusion.
-
-### Clear Output Required
-Every agent must return a summary: what was found, what was fixed, what changed. No silent fixes.
-
-### Conscious Integration
-Don't blindly merge agent work. Review summaries, check conflicts, run full suite, verify compatibility.
-
-## Quick Start
-
-### 1. Identify Independent Domains
-
-Group failures by what's broken:
-```
-File A tests: Tool approval flow
-File B tests: Batch completion behavior
-File C tests: Abort functionality
-```
-
-Each domain is independent - fixing tool approval doesn't affect abort tests.
-
-### 2. Create Focused Agent Tasks
-
-Each agent gets:
-- **Specific scope:** One test file or subsystem
-- **Clear goal:** Make these tests pass
-- **Constraints:** Don't change other code
-- **Expected output:** Summary of what you found and fixed
-
-**→** [agent-prompts.md](references/agent-prompts.md) for prompt templates and examples
-
-### 3. Dispatch in Parallel
-
-```typescript
-// In Claude Code / AI environment
-Task("Fix agent-tool-abort.test.ts failures")
-Task("Fix batch-completion-behavior.test.ts failures")
-Task("Fix tool-approval-race-conditions.test.ts failures")
-// All three run concurrently
-```
-
-**→** [coordination-patterns.md](references/coordination-patterns.md) for dispatch strategies
-
-### 4. Review and Integrate
-
-When agents return:
-- Read each summary - understand what changed
-- Verify fixes don't conflict - check for same file edits
-- Run full test suite - ensure compatibility
-- Spot check changes - agents can make systematic errors
-
-**→** [troubleshooting.md](references/troubleshooting.md) for conflict resolution
-
-## Decision Tree
-
-```
-Multiple failures?
-  └→ Are they independent?
-      ├→ NO (related) → Single agent investigates all
-      └→ YES → Can they work in parallel?
-          ├→ NO (shared state) → Sequential agents
-          └→ YES → Parallel dispatch ✓
-```
-
-## Key Benefits
-
-1. **Parallelization** - Multiple investigations happen simultaneously
-2. **Focus** - Each agent has narrow scope, less context to track
-3. **Independence** - Agents don't interfere with each other
-4. **Speed** - N problems solved in time of 1
-
-## Navigation
-
-### Pattern Reference
-- **[Coordination Patterns](references/coordination-patterns.md)** - Dispatch strategies, domain identification, integration workflows
-
-### Agent Management
-- **[Agent Prompts](references/agent-prompts.md)** - Prompt structure, templates, common mistakes, constraints
-
-### Learning Resources
-- **[Examples](references/examples.md)** - Real-world scenarios, case studies, time savings analysis
-
-### Problem Solving
-- **[Troubleshooting](references/troubleshooting.md)** - Conflict resolution, verification strategies, common pitfalls
-
-### Related Skills
-- **[pm-workflow](../pm-workflow/)** - PM coordination and task management
-- **[test-driven-development](../../testing/test-driven-development/)** - TDD patterns that benefit from parallel fixing
-- **[verification-before-completion](../../productivity/verification-before-completion/)** - Integration verification
-
-## Key Reminders
-
-1. **Independence is mandatory** - Related failures need single-agent investigation
-2. **Focus beats breadth** - Narrow scope per agent prevents confusion
-3. **Always verify integration** - Don't blindly merge agent work
-4. **Clear outputs required** - Every agent returns summary of changes
-5. **Parallelization has overhead** - Only worth it for 3+ independent problems
-
-## Red Flags - STOP
-
-**STOP immediately if:**
-- Agents are editing the same files (scope overlap)
-- Fixes from one agent break another's work (hidden dependencies)
-- You can't clearly separate problem domains (not independent)
-- Agents return no summary (can't verify changes)
-- Integration requires major refactoring (conflicts)
-
-**When in doubt:** Start with one agent, understand the landscape, then dispatch if truly independent.
-
-## Integration with Other Skills
-
-**Prerequisite:** Basic understanding of problem domains and test structure
-**Complementary:** [pm-workflow](../pm-workflow/) for coordinating multiple agents
-**Domain-specific:** Testing skills for understanding test failures
-
-## Real-World Impact
-
-From debugging session (2025-10-03):
-- **6 failures** across 3 test files
-- **3 agents** dispatched in parallel
-- **All investigations** completed concurrently
-- **Zero conflicts** between agent changes
-- **Time saved:** 3 problems solved in parallel vs sequentially
-
-**→** [examples.md](references/examples.md) for detailed case study