claude-mpm 4.13.2__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/skills/bundled/xlsx.md

@@ -0,0 +1,157 @@
+---
+skill_id: xlsx
+skill_version: 0.1.0
+description: Working with Excel files programmatically.
+updated_at: 2025-10-30T17:00:00Z
+tags: [excel, xlsx, spreadsheet, data]
+---
+
+# Excel/XLSX Manipulation
+
+Working with Excel files programmatically.
+
+## Python (openpyxl)
+
+### Reading Excel
+```python
+from openpyxl import load_workbook
+
+wb = load_workbook('data.xlsx')
+ws = wb.active  # Get active sheet
+
+# Read cell
+value = ws['A1'].value
+
+# Iterate rows
+for row in ws.iter_rows(min_row=2, values_only=True):
+    print(row)
+```
+
+### Writing Excel
+```python
+from openpyxl import Workbook
+
+wb = Workbook()
+ws = wb.active
+ws.title = "Data"
+
+# Write data
+ws['A1'] = 'Name'
+ws['B1'] = 'Age'
+ws.append(['John', 30])
+ws.append(['Jane', 25])
+
+wb.save('output.xlsx')
+```
+
+### Formatting
+```python
+from openpyxl.styles import Font, PatternFill
+
+# Bold header
+ws['A1'].font = Font(bold=True)
+
+# Background color
+ws['A1'].fill = PatternFill(start_color="FFFF00", fill_type="solid")
+
+# Number format
+ws['B2'].number_format = '0.00'  # Two decimals
+```
+
+### Formulas
+```python
+# Add formula
+ws['C2'] = '=A2+B2'
+
+# Sum column
+ws['D10'] = '=SUM(D2:D9)'
+```
+
+## Python (pandas)
+
+### Reading Excel
+```python
+import pandas as pd
+
+# Read sheet
+df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
+
+# Read multiple sheets
+dfs = pd.read_excel('data.xlsx', sheet_name=None)
+```
+
+### Writing Excel
+```python
+# Write DataFrame
+df.to_excel('output.xlsx', index=False)
+
+# Multiple sheets
+with pd.ExcelWriter('output.xlsx') as writer:
+    df1.to_excel(writer, sheet_name='Sheet1')
+    df2.to_excel(writer, sheet_name='Sheet2')
+```
+
+### Data Transformation
+```python
+# Filter
+filtered = df[df['Age'] > 25]
+
+# Group by
+grouped = df.groupby('Department')['Salary'].mean()
+
+# Pivot
+pivot = df.pivot_table(values='Sales', index='Region', columns='Product')
+```
+
+## JavaScript (xlsx)
+
+```javascript
+import XLSX from 'xlsx';
+
+// Read file
+const workbook = XLSX.readFile('data.xlsx');
+const sheetName = workbook.SheetNames[0];
+const worksheet = workbook.Sheets[sheetName];
+
+// Convert to JSON
+const data = XLSX.utils.sheet_to_json(worksheet);
+
+// Write file
+const newWorksheet = XLSX.utils.json_to_sheet(data);
+const newWorkbook = XLSX.utils.book_new();
+XLSX.utils.book_append_sheet(newWorkbook, newWorksheet, 'Data');
+XLSX.writeFile(newWorkbook, 'output.xlsx');
+```
+
+## Common Operations
+
+### CSV to Excel
+```python
+import pandas as pd
+
+df = pd.read_csv('data.csv')
+df.to_excel('data.xlsx', index=False)
+```
+
+### Excel to CSV
+```python
+df = pd.read_excel('data.xlsx')
+df.to_csv('data.csv', index=False)
+```
+
+### Merging Excel Files
+```python
+dfs = []
+for file in ['file1.xlsx', 'file2.xlsx', 'file3.xlsx']:
+    df = pd.read_excel(file)
+    dfs.append(df)
+
+combined = pd.concat(dfs, ignore_index=True)
+combined.to_excel('merged.xlsx', index=False)
+```
+
+## Remember
+- Close workbooks after use
+- Handle large files in chunks
+- Validate data before writing
+- Use pandas for data analysis, openpyxl for formatting

claude_mpm/skills/registry.py

@@ -0,0 +1,286 @@
+"""Skills registry - manages bundled and discovered skills."""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class Skill:
+    """Represents a skill that can be used by agents."""
+
+    name: str
+    path: Path
+    content: str
+    source: str  # 'bundled', 'user', or 'project'
+
+    # Version tracking fields
+    version: str = "0.1.0"
+    skill_id: str = ""  # defaults to name if not provided
+
+    # Existing fields
+    description: str = ""
+    agent_types: List[str] = None  # Which agent types can use this skill
+
+    # Optional metadata
+    updated_at: Optional[str] = None
+    tags: List[str] = None
+
+    def __post_init__(self):
+        """Initialize default values if not provided."""
+        if self.agent_types is None:
+            self.agent_types = []
+        if self.tags is None:
+            self.tags = []
+        if not self.skill_id:
+            self.skill_id = self.name
+
+
+class SkillsRegistry:
+    """Registry for managing skills across all tiers."""
+
+    def __init__(self):
+        """Initialize the skills registry."""
+        self.skills: Dict[str, Skill] = {}
+        self._load_bundled_skills()
+        self._load_user_skills()
+        self._load_project_skills()
+
+    def _parse_skill_frontmatter(self, content: str) -> Dict[str, Any]:
+        """Parse YAML frontmatter from skill markdown file.
+
+        Returns:
+            Dict with frontmatter fields or empty dict if no frontmatter
+        """
+        # Check for YAML frontmatter
+        if not content.startswith("---"):
+            return {}
+
+        # Extract frontmatter (match: ---\n...yaml...\n---\nrest)
+        match = re.match(r"^---\n(.*?)\n---\n(.*)$", content, re.DOTALL)
+        if not match:
+            return {}
+
+        try:
+            frontmatter = yaml.safe_load(match.group(1))
+            return frontmatter or {}
+        except yaml.YAMLError as e:
+            logger.warning(f"Failed to parse skill frontmatter: {e}")
+            return {}
+
+    def _load_bundled_skills(self):
+        """Load skills bundled with MPM."""
+        bundled_dir = Path(__file__).parent / "bundled"
+        if not bundled_dir.exists():
+            logger.warning(f"Bundled skills directory not found: {bundled_dir}")
+            return
+
+        skill_count = 0
+        for skill_file in bundled_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                content = skill_file.read_text(encoding="utf-8")
+
+                # Parse frontmatter
+                frontmatter = self._parse_skill_frontmatter(content)
+
+                # Extract version fields from frontmatter
+                version = frontmatter.get("skill_version", "0.1.0")
+                skill_id = frontmatter.get("skill_id", skill_name)
+                updated_at = frontmatter.get("updated_at")
+                tags = frontmatter.get("tags", [])
+
+                # Extract description (from frontmatter or fallback to content parsing)
+                description = frontmatter.get("description", "")
+                if not description:
+                    description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="bundled",
+                    version=version,
+                    skill_id=skill_id,
+                    description=description,
+                    updated_at=updated_at,
+                    tags=tags,
+                )
+                skill_count += 1
+            except Exception as e:
+                logger.error(f"Error loading bundled skill {skill_file}: {e}")
+
+        logger.debug(f"Loaded {skill_count} bundled skills")
+
+    def _load_user_skills(self):
+        """Load user-installed skills from ~/.claude/skills/"""
+        user_skills_dir = Path.home() / ".claude" / "skills"
+        if not user_skills_dir.exists():
+            logger.debug("User skills directory not found, skipping")
+            return
+
+        skill_count = 0
+        for skill_file in user_skills_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                # User skills override bundled skills
+                content = skill_file.read_text(encoding="utf-8")
+
+                # Parse frontmatter
+                frontmatter = self._parse_skill_frontmatter(content)
+
+                # Extract version fields from frontmatter
+                version = frontmatter.get("skill_version", "0.1.0")
+                skill_id = frontmatter.get("skill_id", skill_name)
+                updated_at = frontmatter.get("updated_at")
+                tags = frontmatter.get("tags", [])
+
+                # Extract description (from frontmatter or fallback to content parsing)
+                description = frontmatter.get("description", "")
+                if not description:
+                    description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="user",
+                    version=version,
+                    skill_id=skill_id,
+                    description=description,
+                    updated_at=updated_at,
+                    tags=tags,
+                )
+                skill_count += 1
+                logger.debug(f"User skill '{skill_name}' overrides bundled version")
+            except Exception as e:
+                logger.error(f"Error loading user skill {skill_file}: {e}")
+
+        if skill_count > 0:
+            logger.debug(f"Loaded {skill_count} user skills")
+
+    def _load_project_skills(self):
+        """Load project-specific skills from .claude/skills/"""
+        project_skills_dir = Path.cwd() / ".claude" / "skills"
+        if not project_skills_dir.exists():
+            logger.debug("Project skills directory not found, skipping")
+            return
+
+        skill_count = 0
+        for skill_file in project_skills_dir.glob("*.md"):
+            try:
+                skill_name = skill_file.stem
+                # Project skills override both user and bundled skills
+                content = skill_file.read_text(encoding="utf-8")
+
+                # Parse frontmatter
+                frontmatter = self._parse_skill_frontmatter(content)
+
+                # Extract version fields from frontmatter
+                version = frontmatter.get("skill_version", "0.1.0")
+                skill_id = frontmatter.get("skill_id", skill_name)
+                updated_at = frontmatter.get("updated_at")
+                tags = frontmatter.get("tags", [])
+
+                # Extract description (from frontmatter or fallback to content parsing)
+                description = frontmatter.get("description", "")
+                if not description:
+                    description = self._extract_description(content)
+
+                self.skills[skill_name] = Skill(
+                    name=skill_name,
+                    path=skill_file,
+                    content=content,
+                    source="project",
+                    version=version,
+                    skill_id=skill_id,
+                    description=description,
+                    updated_at=updated_at,
+                    tags=tags,
+                )
+                skill_count += 1
+                logger.debug(f"Project skill '{skill_name}' overrides other versions")
+            except Exception as e:
+                logger.error(f"Error loading project skill {skill_file}: {e}")
+
+        if skill_count > 0:
+            logger.debug(f"Loaded {skill_count} project skills")
+
+    def _extract_description(self, content: str) -> str:
+        """Extract description from skill content (first paragraph or summary)."""
+        lines = content.strip().split("\n")
+        description_lines = []
+
+        # Skip title (first line starting with #)
+        start_idx = 0
+        if lines and lines[0].startswith("#"):
+            start_idx = 1
+
+        # Find first non-empty paragraph
+        for line in lines[start_idx:]:
+            line = line.strip()
+            if not line:
+                if description_lines:
+                    break
+                continue
+            if line.startswith("#"):
+                break
+            description_lines.append(line)
+
+        return " ".join(description_lines)[:200]  # Limit to 200 chars
+
+    def get_skill(self, name: str) -> Optional[Skill]:
+        """Get a skill by name."""
+        return self.skills.get(name)
+
+    def list_skills(self, source: Optional[str] = None) -> List[Skill]:
+        """List all skills, optionally filtered by source."""
+        if source:
+            return [s for s in self.skills.values() if s.source == source]
+        return list(self.skills.values())
+
+    def get_skills_for_agent(self, agent_type: str) -> List[Skill]:
+        """
+        Get skills mapped to a specific agent type.
+
+        Args:
+            agent_type: Agent type/ID (e.g., 'engineer', 'python_engineer')
+
+        Returns:
+            List of skills applicable to this agent type
+        """
+        # Filter skills that explicitly list this agent type
+        # If a skill has no agent_types specified, it's available to all agents
+        return [
+            skill
+            for skill in self.skills.values()
+            if not skill.agent_types or agent_type in skill.agent_types
+        ]
+
+    def reload(self):
+        """Reload all skills from disk."""
+        logger.info("Reloading skills registry...")
+        self.skills.clear()
+        self._load_bundled_skills()
+        self._load_user_skills()
+        self._load_project_skills()
+        logger.info(f"Skills registry reloaded with {len(self.skills)} skills")
+
+
+# Global registry instance (singleton pattern)
+_registry: Optional[SkillsRegistry] = None
+
+
+def get_registry() -> SkillsRegistry:
+    """Get the global skills registry (singleton)."""
+    global _registry
+    if _registry is None:
+        _registry = SkillsRegistry()
+    return _registry