codepp 0.0.437__py3-none-any.whl

code_puppy/plugins/__init__.py

@@ -0,0 +1,186 @@
+import importlib
+import importlib.util
+import logging
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# User plugins directory
+USER_PLUGINS_DIR = Path.home() / ".code_puppy" / "plugins"
+
+# Track if plugins have already been loaded to prevent duplicate registration
+_PLUGINS_LOADED = False
+
+
+def _load_builtin_plugins(plugins_dir: Path) -> list[str]:
+    """Load built-in plugins from the package plugins directory.
+
+    Returns list of successfully loaded plugin names.
+    """
+    # Import safety permission check for shell_safety plugin
+    from code_puppy.config import get_safety_permission_level
+
+    loaded = []
+
+    for item in plugins_dir.iterdir():
+        if item.is_dir() and not item.name.startswith("_"):
+            plugin_name = item.name
+            callbacks_file = item / "register_callbacks.py"
+
+            if callbacks_file.exists():
+                # Skip shell_safety plugin unless safety_permission_level is "low" or "none"
+                if plugin_name == "shell_safety":
+                    safety_level = get_safety_permission_level()
+                    if safety_level not in ("none", "low"):
+                        logger.debug(
+                            f"Skipping shell_safety plugin - safety_permission_level is '{safety_level}' (needs 'low' or 'none')"
+                        )
+                        continue
+
+                try:
+                    module_name = f"code_puppy.plugins.{plugin_name}.register_callbacks"
+                    importlib.import_module(module_name)
+                    loaded.append(plugin_name)
+                except ImportError as e:
+                    logger.warning(
+                        f"Failed to import callbacks from built-in plugin {plugin_name}: {e}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Unexpected error loading built-in plugin {plugin_name}: {e}"
+                    )
+
+    return loaded
+
+
+def _load_user_plugins(user_plugins_dir: Path) -> list[str]:
+    """Load user plugins from ~/.code_puppy/plugins/.
+
+    Each plugin should be a directory containing a register_callbacks.py file.
+    Plugins are loaded by adding their parent to sys.path and importing them.
+
+    Returns list of successfully loaded plugin names.
+    """
+    loaded = []
+
+    if not user_plugins_dir.exists():
+        return loaded
+
+    if not user_plugins_dir.is_dir():
+        logger.warning(f"User plugins path is not a directory: {user_plugins_dir}")
+        return loaded
+
+    # Add user plugins directory to sys.path if not already there
+    user_plugins_str = str(user_plugins_dir)
+    if user_plugins_str not in sys.path:
+        sys.path.insert(0, user_plugins_str)
+
+    for item in user_plugins_dir.iterdir():
+        if (
+            item.is_dir()
+            and not item.name.startswith("_")
+            and not item.name.startswith(".")
+        ):
+            plugin_name = item.name
+            callbacks_file = item / "register_callbacks.py"
+
+            if callbacks_file.exists():
+                try:
+                    # Load the plugin module directly from the file
+                    module_name = f"{plugin_name}.register_callbacks"
+                    spec = importlib.util.spec_from_file_location(
+                        module_name, callbacks_file
+                    )
+                    if spec is None or spec.loader is None:
+                        logger.warning(
+                            f"Could not create module spec for user plugin: {plugin_name}"
+                        )
+                        continue
+
+                    module = importlib.util.module_from_spec(spec)
+                    sys.modules[module_name] = module
+
+                    spec.loader.exec_module(module)
+                    loaded.append(plugin_name)
+
+                except ImportError as e:
+                    logger.warning(
+                        f"Failed to import callbacks from user plugin {plugin_name}: {e}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Unexpected error loading user plugin {plugin_name}: {e}",
+                        exc_info=True,
+                    )
+            else:
+                # Check if there's an __init__.py - might be a simple plugin
+                init_file = item / "__init__.py"
+                if init_file.exists():
+                    try:
+                        module_name = plugin_name
+                        spec = importlib.util.spec_from_file_location(
+                            module_name, init_file
+                        )
+                        if spec is None or spec.loader is None:
+                            continue
+
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[module_name] = module
+                        spec.loader.exec_module(module)
+                        loaded.append(plugin_name)
+
+                    except Exception as e:
+                        logger.error(
+                            f"Unexpected error loading user plugin {plugin_name}: {e}",
+                            exc_info=True,
+                        )
+
+    return loaded
+
+
+def load_plugin_callbacks() -> dict[str, list[str]]:
+    """Dynamically load register_callbacks.py from all plugin sources.
+
+    Loads plugins from:
+    1. Built-in plugins in the code_puppy/plugins/ directory
+    2. User plugins in ~/.code_puppy/plugins/
+
+    Returns dict with 'builtin' and 'user' keys containing lists of loaded plugin names.
+
+    NOTE: This function is idempotent - calling it multiple times will only
+    load plugins once. Subsequent calls return empty lists.
+    """
+    global _PLUGINS_LOADED
+
+    # Prevent duplicate loading - plugins register callbacks at import time,
+    # so re-importing would cause duplicate registrations
+    if _PLUGINS_LOADED:
+        logger.debug("Plugins already loaded, skipping duplicate load")
+        return {"builtin": [], "user": []}
+
+    plugins_dir = Path(__file__).parent
+
+    result = {
+        "builtin": _load_builtin_plugins(plugins_dir),
+        "user": _load_user_plugins(USER_PLUGINS_DIR),
+    }
+
+    _PLUGINS_LOADED = True
+    logger.debug(f"Loaded plugins: builtin={result['builtin']}, user={result['user']}")
+
+    return result
+
+
+def get_user_plugins_dir() -> Path:
+    """Return the path to the user plugins directory."""
+    return USER_PLUGINS_DIR
+
+
+def ensure_user_plugins_dir() -> Path:
+    """Create the user plugins directory if it doesn't exist.
+
+    Returns the path to the directory.
+    """
+    USER_PLUGINS_DIR.mkdir(parents=True, exist_ok=True)
+    return USER_PLUGINS_DIR

code_puppy/plugins/agent_skills/__init__.py

@@ -0,0 +1,22 @@
+"""Agent Skills plugin - dynamic skill loading and discovery.
+
+This plugin enables code_puppy to discover, load, and use custom skills
+defined in SKILL.md files. Skills can be placed in user-specific or
+project-specific directories for easy sharing and organization.
+"""
+
+from .metadata import (
+    SkillMetadata,
+    get_skill_resources,
+    load_full_skill_content,
+    parse_skill_metadata,
+    parse_yaml_frontmatter,
+)
+
+__all__ = [
+    "SkillMetadata",
+    "parse_yaml_frontmatter",
+    "parse_skill_metadata",
+    "load_full_skill_content",
+    "get_skill_resources",
+]

code_puppy/plugins/agent_skills/config.py

@@ -0,0 +1,175 @@
+"""Plugin-level config helpers for agent_skills."""
+
+import json
+import logging
+from pathlib import Path
+from typing import List, Set
+
+from code_puppy.config import get_value, set_value
+
+logger = logging.getLogger(__name__)
+
+
+def get_skill_directories() -> List[str]:
+    """Get configured skill directories.
+
+    Returns:
+        List of skill directory paths from configuration.
+        Reads from puppy.cfg [puppy] section under 'skill_directories' key.
+        Default: ['~/.code_puppy/skills', './.code_puppy/skills', './skills']
+
+    The directories are stored as a JSON list in the config.
+    """
+    # Try to read from config first
+    config_value = get_value("skill_directories")
+
+    if config_value:
+        try:
+            # Parse as JSON
+            directories = json.loads(config_value)
+            # Ensure it's a list
+            if isinstance(directories, list):
+                return directories
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse skill_directories config: {e}")
+
+    # Fallback to defaults
+    home_skills = str(Path.home() / ".code_puppy" / "skills")
+    project_config_skills = str(Path.cwd() / ".code_puppy" / "skills")
+    local_skills = str(Path.cwd() / "skills")
+    return [
+        home_skills,
+        project_config_skills,
+        local_skills,
+    ]
+
+
+def add_skill_directory(path: str) -> bool:
+    """Add a directory to the skills search path.
+
+    Args:
+        path: Path to add to the skill directories list.
+
+    Returns:
+        True if the directory was added successfully, False otherwise.
+    """
+    directories = get_skill_directories()
+
+    # Check if already exists
+    if path in directories:
+        logger.info(f"Skill directory already exists: {path}")
+        return False
+
+    # Add the new directory
+    directories.append(path)
+
+    try:
+        # Save back to config as JSON
+        set_value("skill_directories", json.dumps(directories))
+        logger.info(f"Added skill directory: {path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to add skill directory: {e}")
+        return False
+
+
+def remove_skill_directory(path: str) -> bool:
+    """Remove a directory from the skills search path.
+
+    Args:
+        path: Path to remove from the skill directories list.
+
+    Returns:
+        True if the directory was removed successfully, False otherwise.
+    """
+    directories = get_skill_directories()
+
+    # Check if exists
+    if path not in directories:
+        logger.info(f"Skill directory not found: {path}")
+        return False
+
+    # Remove the directory
+    directories.remove(path)
+
+    try:
+        # Save back to config as JSON
+        set_value("skill_directories", json.dumps(directories))
+        logger.info(f"Removed skill directory: {path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to remove skill directory: {e}")
+        return False
+
+
+def get_skills_enabled() -> bool:
+    """Check if skills integration is globally enabled.
+
+    Returns:
+        True if skills are globally enabled, False otherwise.
+        Reads from 'skills_enabled' config key (default: True).
+    """
+    cfg_val = get_value("skills_enabled")
+    if cfg_val is None:
+        return True  # Enabled by default
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def set_skills_enabled(enabled: bool) -> None:
+    """Enable or disable skills integration globally.
+
+    Args:
+        enabled: True to enable, False to disable.
+    """
+    set_value("skills_enabled", "true" if enabled else "false")
+    logger.info(f"Skills integration {'enabled' if enabled else 'disabled'}")
+
+
+def get_disabled_skills() -> Set[str]:
+    """Get set of explicitly disabled skill names.
+
+    Returns:
+        Set of skill names that are disabled.
+        Reads from 'disabled_skills' config key as a JSON list.
+    """
+    config_value = get_value("disabled_skills")
+
+    if config_value:
+        try:
+            # Parse as JSON
+            disabled_list = json.loads(config_value)
+            # Ensure it's a list and convert to set
+            if isinstance(disabled_list, list):
+                return set(disabled_list)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse disabled_skills config: {e}")
+
+    return set()
+
+
+def set_skill_disabled(skill_name: str, disabled: bool) -> None:
+    """Disable or re-enable a specific skill.
+
+    Args:
+        skill_name: Name of the skill to disable/enable.
+        disabled: True to disable, False to enable.
+    """
+    disabled_skills = get_disabled_skills()
+
+    if disabled:
+        # Add to disabled set
+        if skill_name in disabled_skills:
+            logger.info(f"Skill already disabled: {skill_name}")
+            return
+        disabled_skills.add(skill_name)
+        logger.info(f"Disabled skill: {skill_name}")
+    else:
+        # Remove from disabled set
+        if skill_name not in disabled_skills:
+            logger.info(f"Skill already enabled: {skill_name}")
+            return
+        disabled_skills.remove(skill_name)
+        logger.info(f"Enabled skill: {skill_name}")
+
+    # Save back to config as JSON
+    set_value("disabled_skills", json.dumps(list(disabled_skills)))

code_puppy/plugins/agent_skills/discovery.py

@@ -0,0 +1,136 @@
+"""Skill discovery - scans directories for valid skills."""
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from code_puppy.plugins.agent_skills.config import get_skill_directories
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SkillInfo:
+    """Basic skill information from discovery."""
+
+    name: str
+    path: Path
+    has_skill_md: bool
+
+
+# Global cache for discovered skills
+_skill_cache: Optional[List[SkillInfo]] = None
+
+
+def get_default_skill_directories() -> List[Path]:
+    """Return default directories to scan for skills.
+
+    Returns:
+        - ~/.code_puppy/skills (user skills)
+        - ./.code_puppy/skills (project config skills)
+        - ./skills (project skills)
+    """
+    return [
+        Path.home() / ".code_puppy" / "skills",
+        Path.cwd() / ".code_puppy" / "skills",
+        Path.cwd() / "skills",
+    ]
+
+
+def is_valid_skill_directory(path: Path) -> bool:
+    """Check if a directory contains a valid SKILL.md file.
+
+    Args:
+        path: Directory path to check.
+
+    Returns:
+        True if the directory is a valid skill directory, False otherwise.
+    """
+    if not path.is_dir():
+        return False
+
+    skill_md_path = path / "SKILL.md"
+    return skill_md_path.is_file()
+
+
+def discover_skills(directories: Optional[List[Path]] = None) -> List[SkillInfo]:
+    """Scan directories for valid skills.
+
+    Args:
+        directories: Directories to scan. If None, uses configured
+                     directories (which includes user-added ones from /skills menu).
+
+    Returns:
+        List of discovered SkillInfo objects.
+    """
+    global _skill_cache
+
+    if directories is None:
+        # Use configured directories (respects user-added dirs from /skills menu)
+        # then merge with defaults to ensure we always check the standard locations
+        configured = [Path(d) for d in get_skill_directories()]
+        defaults = get_default_skill_directories()
+        # Merge: configured first, then any defaults not already covered
+        seen = {p.resolve() for p in configured}
+        directories = list(configured)
+        for d in defaults:
+            if d.resolve() not in seen:
+                directories.append(d)
+
+    discovered_skills: List[SkillInfo] = []
+
+    for directory in directories:
+        if not directory.exists():
+            logger.debug(f"Skill directory does not exist: {directory}")
+            continue
+
+        if not directory.is_dir():
+            logger.warning(f"Skill path is not a directory: {directory}")
+            continue
+
+        # Scan subdirectories within the skill directory
+        for skill_dir in directory.iterdir():
+            if not skill_dir.is_dir():
+                continue
+
+            # Skip hidden directories
+            if skill_dir.name.startswith("."):
+                continue
+
+            has_skill_md = is_valid_skill_directory(skill_dir)
+
+            # Include if it has SKILL.md (valid skill) or just for discovery
+            skill_info = SkillInfo(
+                name=skill_dir.name, path=skill_dir, has_skill_md=has_skill_md
+            )
+            discovered_skills.append(skill_info)
+
+            if has_skill_md:
+                logger.debug(f"Discovered valid skill: {skill_dir.name} at {skill_dir}")
+            else:
+                logger.debug(
+                    f"Found skill directory without SKILL.md: {skill_dir.name}"
+                )
+
+    # Update cache
+    _skill_cache = discovered_skills
+
+    logger.info(
+        f"Discovered {len(discovered_skills)} skills from {len(directories)} directories"
+    )
+    return discovered_skills
+
+
+def refresh_skill_cache() -> List[SkillInfo]:
+    """Force re-discovery of all skills.
+
+    This clears the cache and performs a fresh scan of all default
+    skill directories.
+
+    Returns:
+        List of freshly discovered SkillInfo objects.
+    """
+    global _skill_cache
+    _skill_cache = None
+    return discover_skills()