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

claude_mpm/core/unified_agent_registry.py

@@ -27,17 +27,18 @@ Architecture:
 
 import contextlib
 import json
-import logging
 import time
 from dataclasses import asdict, dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Union
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .unified_paths import get_path_manager
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class AgentTier(Enum):
@@ -167,11 +168,26 @@ class UnifiedAgentRegistry:
         if project_path.exists():
             self.discovery_paths.append(project_path)
 
+        # Also check for local JSON templates in .claude-mpm/agents/
+        local_project_path = self.path_manager.project_root / ".claude-mpm" / "agents"
+        if (
+            local_project_path.exists()
+            and local_project_path not in self.discovery_paths
+        ):
+            self.discovery_paths.append(local_project_path)
+            logger.debug(f"Added local project templates path: {local_project_path}")
+
         # User-level agents
         user_path = self.path_manager.get_user_agents_dir()
         if user_path.exists():
             self.discovery_paths.append(user_path)
 
+        # Also check for user JSON templates in ~/.claude-mpm/agents/
+        local_user_path = Path.home() / ".claude-mpm" / "agents"
+        if local_user_path.exists() and local_user_path not in self.discovery_paths:
+            self.discovery_paths.append(local_user_path)
+            logger.debug(f"Added local user templates path: {local_user_path}")
+
         # System-level agents (includes templates as a subdirectory)
         system_path = self.path_manager.get_system_agents_dir()
         if system_path.exists():
@@ -328,7 +344,48 @@ class UnifiedAgentRegistry:
                 file_path, agent_format
             )
 
-            return AgentMetadata(
+            # For JSON files, extract additional metadata
+            version = "1.0.0"
+            author = ""
+            tags = []
+
+            if agent_format == AgentFormat.JSON:
+                try:
+                    content = file_path.read_text(encoding="utf-8")
+                    data = json.loads(content)
+
+                    # Extract version
+                    version = data.get("agent_version", data.get("version", "1.0.0"))
+
+                    # Extract author (use project name for local agents)
+                    author = data.get("author", "")
+                    if not author and ".claude-mpm" in str(file_path):
+                        # For local agents, use project directory name as author
+                        project_root = file_path
+                        while project_root.parent != project_root:
+                            if (project_root / ".claude-mpm").exists():
+                                author = project_root.name
+                                break
+                            project_root = project_root.parent
+
+                    # Extract tags (handle both list and comma-separated string formats)
+                    if "metadata" in data:
+                        tags_raw = data["metadata"].get("tags", [])
+                        if isinstance(tags_raw, str):
+                            tags = [
+                                tag.strip()
+                                for tag in tags_raw.split(",")
+                                if tag.strip()
+                            ]
+                        else:
+                            tags = tags_raw if isinstance(tags_raw, list) else []
+
+                except Exception as e:
+                    logger.debug(
+                        f"Could not extract extra JSON metadata from {file_path}: {e}"
+                    )
+
+            metadata = AgentMetadata(
                 name=agent_name,
                 agent_type=agent_type,
                 tier=tier,
@@ -337,8 +394,24 @@ class UnifiedAgentRegistry:
                 last_modified=file_path.stat().st_mtime,
                 description=description,
                 specializations=specializations,
+                version=version,
+                author=author,
+                tags=tags,
             )
 
+            # Set higher priority for local agents
+            if ".claude-mpm" in str(file_path):
+                if tier == AgentTier.PROJECT:
+                    # Highest priority for project-local agents
+                    metadata.tags.append("local")
+                    metadata.tags.append("project")
+                elif tier == AgentTier.USER:
+                    # High priority for user-local agents
+                    metadata.tags.append("local")
+                    metadata.tags.append("user")
+
+            return metadata
+
         except Exception as e:
             logger.error(f"Failed to create metadata for {file_path}: {e}")
             return None
@@ -387,8 +460,39 @@ class UnifiedAgentRegistry:
 
             if agent_format == AgentFormat.JSON:
                 data = json.loads(content)
-                description = data.get("description", "")
-                specializations = data.get("specializations", [])
+
+                # Ensure data is a dictionary, not a list
+                if not isinstance(data, dict):
+                    logger.warning(
+                        f"Invalid JSON structure in {file_path}: expected object, got {type(data).__name__}"
+                    )
+                    return "", []
+
+                # Handle local agent JSON templates with metadata structure
+                if "metadata" in data:
+                    metadata = data["metadata"]
+                    description = metadata.get(
+                        "description", data.get("description", "")
+                    )
+                    specializations = metadata.get(
+                        "specializations", data.get("specializations", [])
+                    )
+
+                    # Extract tags as specializations if present (handle both formats)
+                    tags_raw = metadata.get("tags", [])
+                    if isinstance(tags_raw, str):
+                        tags = [
+                            tag.strip() for tag in tags_raw.split(",") if tag.strip()
+                        ]
+                    else:
+                        tags = tags_raw if isinstance(tags_raw, list) else []
+                    if tags and not specializations:
+                        specializations = tags
+                else:
+                    # Fallback to direct fields
+                    description = data.get("description", "")
+                    specializations = data.get("specializations", [])
+
             elif agent_format in [AgentFormat.YAML, AgentFormat.YAML]:
                 try:
                     import yaml
@@ -420,8 +524,8 @@ class UnifiedAgentRegistry:
             for _i, line in enumerate(lines[1:], 1):
                 if line.strip() == "---":
                     break
-                if line.startswith("description:"):
-                    return line.split(":", 1)[1].strip().strip("\"'")
+                if line.strip().startswith("description:"):
+                    return line.strip().split(":", 1)[1].strip().strip("\"'")
 
         # Look for first paragraph
         for line in lines:
@@ -615,7 +719,7 @@ class UnifiedAgentRegistry:
 
         export_data = {
             "metadata": {
-                "export_time": datetime.now().isoformat(),
+                "export_time": datetime.now(timezone.utc).isoformat(),
                 "total_agents": len(self.registry),
                 "discovery_paths": [str(p) for p in self.discovery_paths],
             },
@@ -624,7 +728,7 @@ class UnifiedAgentRegistry:
             },
         }
 
-        with open(output_path, "w") as f:
+        with output_path.open("w") as f:
             json.dump(export_data, f, indent=2)
 
         logger.info(f"Exported {len(self.registry)} agents to {output_path}")
@@ -633,7 +737,7 @@ class UnifiedAgentRegistry:
         """Import registry from JSON file."""
         input_path = Path(input_path)
 
-        with open(input_path) as f:
+        with input_path.open() as f:
             data = json.load(f)
 
         # Clear current registry

claude_mpm/core/unified_config.py

@@ -436,7 +436,7 @@ class ConfigurationService:
                 if config_path.exists():
                     import yaml
 
-                    with open(config_path) as f:
+                    with config_path.open() as f:
                         file_config = yaml.safe_load(f) or {}
                     config_data.update(file_config)
                     break
@@ -448,7 +448,7 @@ class ConfigurationService:
             raise ConfigurationError(
                 f"Failed to load configuration: {e}",
                 context={"error_type": type(e).__name__},
-            )
+            ) from e
 
     @property
     def config(self) -> UnifiedConfig:
@@ -515,7 +515,7 @@ class ConfigurationService:
                 return True
             raise ConfigurationError("Invalid SocketIO port range")
         except Exception as e:
-            raise ConfigurationError(f"Configuration validation failed: {e}")
+            raise ConfigurationError(f"Configuration validation failed: {e}") from e
 
     def export_to_file(self, file_path: Union[str, Path], format: str = "yaml") -> None:
         """
@@ -531,12 +531,12 @@ class ConfigurationService:
             if format.lower() == "yaml":
                 import yaml
 
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     yaml.dump(self._config.dict(), f, default_flow_style=False)
             elif format.lower() == "json":
                 import json
 
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     json.dump(self._config.dict(), f, indent=2)
             else:
                 raise ConfigurationError(f"Unsupported export format: {format}")
@@ -545,4 +545,4 @@ class ConfigurationService:
             raise ConfigurationError(
                 f"Failed to export configuration: {e}",
                 context={"file_path": str(file_path), "format": format},
-            )
+            ) from e

claude_mpm/core/unified_paths.py

@@ -24,7 +24,6 @@ Architecture:
 - Cached properties with smart invalidation
 """
 
-import logging
 import os
 import sys
 from enum import Enum
@@ -32,7 +31,9 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Optional, Union
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class PathType(Enum):
@@ -82,11 +83,12 @@ class PathContext:
             # Check if we're in a src/ directory structure with pyproject.toml
             current = module_path
             for _ in range(5):  # Check up to 5 levels up
-                if (current / "pyproject.toml").exists():
-                    # Found pyproject.toml, check if this looks like a development setup
-                    if (current / "src" / "claude_mpm").exists():
-                        logger.debug(f"Found development installation at {current}")
-                        return True
+                if (current / "pyproject.toml").exists() and (
+                    current / "src" / "claude_mpm"
+                ).exists():
+                    # Found pyproject.toml with development setup
+                    logger.debug(f"Found development installation at {current}")
+                    return True
                 if current == current.parent:
                     break
                 current = current.parent
@@ -177,7 +179,7 @@ class PathContext:
         """
         # Check for environment variable override
         if os.environ.get("CLAUDE_MPM_DEV_MODE", "").lower() in ("1", "true", "yes"):
-            logger.info(
+            logger.debug(
                 "Development mode forced via CLAUDE_MPM_DEV_MODE environment variable"
             )
             return DeploymentContext.DEVELOPMENT
@@ -197,10 +199,10 @@ class PathContext:
                         'name = "claude-mpm"' in pyproject_content
                         or '"claude-mpm"' in pyproject_content
                     ):
-                        logger.info(
+                        logger.debug(
                             f"Detected claude-mpm development directory at {current}"
                         )
-                        logger.info(
+                        logger.debug(
                             "Using development mode for local source preference"
                         )
                         return DeploymentContext.DEVELOPMENT
@@ -218,7 +220,7 @@ class PathContext:
             # First check if this is an editable install, regardless of path
             # This is important for cases where pipx points to a development installation
             if PathContext._is_editable_install():
-                logger.info("Detected editable/development installation")
+                logger.debug("Detected editable/development installation")
                 # Check if we should use development paths
                 # This could be because we're in a src/ directory or running from dev directory
                 if module_path.parent.name == "src":
@@ -232,7 +234,7 @@ class PathContext:
                         if (current / "src" / "claude_mpm").exists() and (
                             current / "pyproject.toml"
                         ).exists():
-                            logger.info(
+                            logger.debug(
                                 "Running pipx from development directory, using development mode"
                             )
                             return DeploymentContext.DEVELOPMENT
@@ -248,33 +250,33 @@ class PathContext:
                 module_path.parent.name == "src"
                 and (module_path.parent.parent / "src" / "claude_mpm").exists()
             ):
-                logger.info(
+                logger.debug(
                     f"Detected development mode via directory structure at {module_path}"
                 )
                 return DeploymentContext.DEVELOPMENT
 
             # Check for pipx install
             if "pipx" in str(module_path):
-                logger.info(f"Detected pipx installation at {module_path}")
+                logger.debug(f"Detected pipx installation at {module_path}")
                 return DeploymentContext.PIPX_INSTALL
 
             # Check for system package
             if "dist-packages" in str(module_path):
-                logger.info(f"Detected system package installation at {module_path}")
+                logger.debug(f"Detected system package installation at {module_path}")
                 return DeploymentContext.SYSTEM_PACKAGE
 
             # Check for site-packages (could be pip or editable)
             if "site-packages" in str(module_path):
                 # Already checked for editable above, so this is a regular pip install
-                logger.info(f"Detected pip installation at {module_path}")
+                logger.debug(f"Detected pip installation at {module_path}")
                 return DeploymentContext.PIP_INSTALL
 
             # Default to pip install
-            logger.info(f"Defaulting to pip installation for {module_path}")
+            logger.debug(f"Defaulting to pip installation for {module_path}")
             return DeploymentContext.PIP_INSTALL
 
         except ImportError:
-            logger.info(
+            logger.debug(
                 "ImportError during context detection, defaulting to development"
             )
             return DeploymentContext.DEVELOPMENT
@@ -320,7 +322,8 @@ class UnifiedPathManager:
         ]
         self._initialized = True
 
-        logger.info(
+        # Use debug level for initialization details
+        logger.debug(
             f"UnifiedPathManager initialized with context: {self._deployment_context.value}"
         )
 
@@ -394,7 +397,7 @@ class UnifiedPathManager:
                     return current
                 current = current.parent
 
-            raise FileNotFoundError("Could not determine framework root")
+            raise FileNotFoundError("Could not determine framework root") from None
 
     @property
     @lru_cache(maxsize=1)

claude_mpm/dashboard/analysis_runner.py

@@ -20,7 +20,7 @@ import subprocess
 import sys
 import threading
 from dataclasses import asdict, dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from queue import Queue
 from typing import Any, Dict, List, Optional
@@ -41,7 +41,7 @@ class AnalysisRequest:
 
     def __post_init__(self):
         if self.timestamp is None:
-            self.timestamp = datetime.utcnow()
+            self.timestamp = datetime.now(timezone.utc)
 
 
 class CodeAnalysisRunner:
@@ -433,7 +433,7 @@ class CodeAnalysisRunner:
         if self.server:
             # Add timestamp if not present
             if "timestamp" not in data:
-                data["timestamp"] = datetime.utcnow().isoformat()
+                data["timestamp"] = datetime.now(timezone.utc).isoformat()
 
             # Broadcast to all clients
             self.server.broadcast_event(event_type, data)
@@ -450,6 +450,6 @@ class CodeAnalysisRunner:
             {
                 "request_id": request_id,
                 "message": message,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )

claude_mpm/dashboard/api/simple_directory.py

@@ -0,0 +1,261 @@
+"""Simple directory listing API with proper filtering to match main code explorer"""
+
+from pathlib import Path
+
+from aiohttp import web
+
+# Import GitignoreManager from the proper package location
+from claude_mpm.tools.code_tree_analyzer import GitignoreManager
+
+# Code extensions from main explorer
+CODE_EXTENSIONS = {
+    # Programming Languages
+    ".py",
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".mjs",
+    ".cjs",
+    ".java",
+    ".cpp",
+    ".c",
+    ".h",
+    ".hpp",
+    ".cs",
+    ".go",
+    ".rs",
+    ".rb",
+    ".php",
+    ".swift",
+    ".kt",
+    ".scala",
+    ".r",
+    ".m",
+    ".mm",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".fish",
+    ".ps1",
+    ".bat",
+    ".cmd",
+    ".sql",
+    # Web & Data
+    ".html",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".xml",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".ini",
+    ".cfg",
+    ".conf",
+    # Documentation
+    ".md",
+    ".rst",
+    ".txt",
+}
+
+# Directories to always skip
+SKIP_DIRS = {
+    "node_modules",
+    "__pycache__",
+    ".git",
+    ".venv",
+    "venv",
+    "dist",
+    "build",
+    ".tox",
+    "htmlcov",
+    ".pytest_cache",
+    ".mypy_cache",
+    "coverage",
+    ".idea",
+    ".vscode",
+    "env",
+    ".coverage",
+    "__MACOSX",
+    ".ipynb_checkpoints",
+}
+
+# Dotfiles that are allowed to be shown
+DOTFILE_EXCEPTIONS = {
+    ".env.example",
+    ".env.sample",
+    ".gitlab-ci.yml",
+    ".travis.yml",
+    ".dockerignore",
+    ".editorconfig",
+    ".eslintrc",
+    ".prettierrc",
+    ".gitignore",
+}
+
+
+def has_code_files(directory_path, max_depth=5, current_depth=0):
+    """Check if a directory contains code files (matching main explorer logic)"""
+    if current_depth >= max_depth:
+        return False
+
+    try:
+        for item in list(Path(directory_path).iterdir()):
+            # Skip hidden files/dirs unless in exceptions
+            if item.startswith(".") and item not in DOTFILE_EXCEPTIONS:
+                continue
+
+            item_path = Path(directory_path) / item
+
+            if Path(item_path).is_file():
+                # Check if it's a code file
+                ext = Path(item).suffix.lower()
+                if ext in CODE_EXTENSIONS:
+                    return True
+            elif Path(item_path).is_dir():
+                # Skip certain directories
+                if item in SKIP_DIRS or item.endswith(".egg-info"):
+                    continue
+                # Recursively check subdirectories
+                if has_code_files(item_path, max_depth, current_depth + 1):
+                    return True
+    except (PermissionError, OSError):
+        pass
+
+    return False
+
+
+def should_show_item(item_name, item_path, is_directory):
+    """Determine if an item should be shown based on filtering rules"""
+    # Always hide system files
+    if item_name in {".DS_Store", "Thumbs.db", "desktop.ini"}:
+        return False
+
+    # Hide files with certain extensions
+    if item_name.endswith((".pyc", ".pyo", ".pyd")):
+        return False
+
+    # Handle dotfiles
+    if item_name.startswith("."):
+        # Only show specific dotfile exceptions
+        return item_name in DOTFILE_EXCEPTIONS
+
+    if is_directory:
+        # Skip certain directories
+        if item_name in SKIP_DIRS or item_name.endswith(".egg-info"):
+            return False
+
+        # Only show directories that have code files or subdirectories
+        if not has_code_files(item_path, max_depth=3):
+            # Check if it has any visible subdirectories
+            try:
+                for subitem in list(Path(item_path).iterdir()):
+                    subitem_path = Path(item_path) / subitem
+                    if Path(subitem_path).is_dir():
+                        if not subitem.startswith(".") and subitem not in SKIP_DIRS:
+                            return True
+                return False
+            except (PermissionError, OSError):
+                return False
+    else:
+        # For files, check if it's a code file or documentation
+        ext = Path(item_name).suffix.lower()
+        if ext in CODE_EXTENSIONS:
+            return True
+
+        # Show certain config files even without extensions
+        base_name = item_name.lower()
+        if base_name in {
+            "makefile",
+            "dockerfile",
+            "jenkinsfile",
+            "rakefile",
+            "gemfile",
+        }:
+            return True
+
+        # Hide other non-code files
+        return False
+
+    return True
+
+
+async def list_directory(request):
+    """Directory listing with filtering to match main code explorer"""
+    path = request.query.get("path", ".")
+
+    # Convert to absolute path
+    abs_path = Path(Path(path).resolve().expanduser())
+
+    result = {
+        "path": abs_path,
+        "exists": Path(abs_path).exists(),
+        "is_directory": Path(abs_path).is_dir(),
+        "contents": [],
+        "filtered": True,  # Indicate that filtering is applied
+        "filter_info": "Showing only code files and directories with code",
+    }
+
+    if result["exists"] and result["is_directory"]:
+        try:
+            # Initialize gitignore manager for this directory
+            gitignore_mgr = GitignoreManager()
+
+            # List all items
+            items = list(Path(abs_path).iterdir())
+
+            for item in items:
+                item_path = Path(abs_path) / item
+                is_directory = Path(item_path).is_dir()
+
+                # Check if item should be ignored by gitignore
+                if gitignore_mgr.should_ignore(Path(item_path), Path(abs_path)):
+                    continue
+
+                # Apply additional filtering rules
+                if not should_show_item(item, item_path, is_directory):
+                    continue
+
+                # Add to results
+                result["contents"].append(
+                    {
+                        "name": item,
+                        "path": item_path,
+                        "is_directory": is_directory,
+                        "is_file": Path(item_path).is_file(),
+                        "is_code_file": not is_directory
+                        and any(item.endswith(ext) for ext in CODE_EXTENSIONS),
+                    }
+                )
+
+            # Sort: directories first, then files
+            result["contents"].sort(
+                key=lambda x: (not x["is_directory"], x["name"].lower())
+            )
+
+            # Add summary statistics
+            dir_count = sum(1 for x in result["contents"] if x["is_directory"])
+            file_count = len(result["contents"]) - dir_count
+            code_file_count = sum(
+                1 for x in result["contents"] if x.get("is_code_file", False)
+            )
+
+            result["summary"] = {
+                "total_items": len(result["contents"]),
+                "directories": dir_count,
+                "files": file_count,
+                "code_files": code_file_count,
+            }
+
+        except Exception as e:
+            result["error"] = str(e)
+
+    return web.json_response(result)
+
+
+def register_routes(app):
+    """Register simple directory routes with the aiohttp app"""
+    app.router.add_get("/api/directory/list", list_directory)