cldpm 0.1.0__py3-none-any.whl

cldpm/core/__init__.py

@@ -0,0 +1,26 @@
+"""Core functionality for CLDPM."""
+
+from .config import load_cldpm_config, save_cldpm_config, load_project_config, save_project_config
+from .linker import (
+    create_symlink,
+    sync_project_links,
+    remove_project_links,
+    get_local_components,
+    get_shared_components,
+    update_component_gitignore,
+)
+from .resolver import resolve_project
+
+__all__ = [
+    "load_cldpm_config",
+    "save_cldpm_config",
+    "load_project_config",
+    "save_project_config",
+    "create_symlink",
+    "sync_project_links",
+    "remove_project_links",
+    "get_local_components",
+    "get_shared_components",
+    "update_component_gitignore",
+    "resolve_project",
+]

cldpm/core/config.py

@@ -0,0 +1,182 @@
+"""Configuration loading and saving for CLDPM."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from ..schemas import CldpmConfig, ComponentMetadata, ProjectConfig
+from ..utils.fs import find_repo_root
+
+
+def load_cldpm_config(repo_root: Optional[Path] = None) -> CldpmConfig:
+    """Load the cldpm.json configuration.
+
+    Args:
+        repo_root: Path to the repo root. If None, will search for it.
+
+    Returns:
+        The loaded CldpmConfig.
+
+    Raises:
+        FileNotFoundError: If cldpm.json is not found.
+        ValueError: If cldpm.json is invalid.
+    """
+    if repo_root is None:
+        repo_root = find_repo_root()
+        if repo_root is None:
+            raise FileNotFoundError(
+                "Not in a CLDPM mono repo. Run 'cldpm init' to create one."
+            )
+
+    config_path = repo_root / "cldpm.json"
+    if not config_path.exists():
+        raise FileNotFoundError(f"cldpm.json not found at {config_path}")
+
+    with open(config_path, "r") as f:
+        data = json.load(f)
+
+    return CldpmConfig.model_validate(data)
+
+
+def save_cldpm_config(config: CldpmConfig, repo_root: Path) -> None:
+    """Save the cldpm.json configuration.
+
+    Args:
+        config: The CldpmConfig to save.
+        repo_root: Path to the repo root.
+    """
+    config_path = repo_root / "cldpm.json"
+    with open(config_path, "w") as f:
+        json.dump(config.model_dump(by_alias=True), f, indent=2)
+        f.write("\n")
+
+
+def load_project_config(project_path: Path) -> ProjectConfig:
+    """Load a project.json configuration.
+
+    Args:
+        project_path: Path to the project directory.
+
+    Returns:
+        The loaded ProjectConfig.
+
+    Raises:
+        FileNotFoundError: If project.json is not found.
+        ValueError: If project.json is invalid.
+    """
+    config_path = project_path / "project.json"
+    if not config_path.exists():
+        raise FileNotFoundError(f"project.json not found at {config_path}")
+
+    with open(config_path, "r") as f:
+        data = json.load(f)
+
+    return ProjectConfig.model_validate(data)
+
+
+def save_project_config(config: ProjectConfig, project_path: Path) -> None:
+    """Save a project.json configuration.
+
+    Args:
+        config: The ProjectConfig to save.
+        project_path: Path to the project directory.
+    """
+    config_path = project_path / "project.json"
+    with open(config_path, "w") as f:
+        json.dump(config.model_dump(exclude_none=True), f, indent=2)
+        f.write("\n")
+
+
+def get_project_path(
+    project_name: str, repo_root: Optional[Path] = None
+) -> Optional[Path]:
+    """Get the path to a project by name.
+
+    Args:
+        project_name: Name of the project.
+        repo_root: Path to the repo root. If None, will search for it.
+
+    Returns:
+        Path to the project directory, or None if not found.
+    """
+    if repo_root is None:
+        repo_root = find_repo_root()
+        if repo_root is None:
+            return None
+
+    config = load_cldpm_config(repo_root)
+    project_path = repo_root / config.projects_dir / project_name
+
+    if project_path.exists() and (project_path / "project.json").exists():
+        return project_path
+
+    return None
+
+
+def list_projects(repo_root: Optional[Path] = None) -> list[Path]:
+    """List all projects in the mono repo.
+
+    Args:
+        repo_root: Path to the repo root. If None, will search for it.
+
+    Returns:
+        List of paths to project directories.
+    """
+    if repo_root is None:
+        repo_root = find_repo_root()
+        if repo_root is None:
+            return []
+
+    config = load_cldpm_config(repo_root)
+    projects_dir = repo_root / config.projects_dir
+
+    if not projects_dir.exists():
+        return []
+
+    projects = []
+    for item in projects_dir.iterdir():
+        if item.is_dir() and (item / "project.json").exists():
+            projects.append(item)
+
+    return sorted(projects)
+
+
+def load_component_metadata(
+    comp_type: str, comp_name: str, repo_root: Path
+) -> Optional[ComponentMetadata]:
+    """Load metadata for a shared component.
+
+    Looks for a metadata file (skill.json, agent.json, hook.json, rule.json)
+    in the component directory.
+
+    Args:
+        comp_type: Component type (skills, agents, hooks, rules).
+        comp_name: Component name.
+        repo_root: Path to the repo root.
+
+    Returns:
+        ComponentMetadata if found, None otherwise.
+    """
+    config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / config.shared_dir
+
+    component_path = shared_dir / comp_type / comp_name
+    if not component_path.exists():
+        return None
+
+    # Try different metadata file names
+    singular_type = comp_type.rstrip("s")  # skills -> skill
+    metadata_files = [
+        f"{singular_type}.json",  # skill.json, agent.json, etc.
+        "metadata.json",  # Generic fallback
+    ]
+
+    for metadata_file in metadata_files:
+        metadata_path = component_path / metadata_file
+        if metadata_path.exists():
+            with open(metadata_path, "r") as f:
+                data = json.load(f)
+            return ComponentMetadata.model_validate(data)
+
+    # Return minimal metadata if no metadata file exists
+    return ComponentMetadata(name=comp_name)

cldpm/core/linker.py

@@ -0,0 +1,265 @@
+"""Symlink management for CLDPM projects."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from ..schemas import ProjectConfig
+from ..utils.fs import ensure_dir, find_repo_root
+from .config import load_cldpm_config, load_project_config
+
+
+def create_symlink(source: Path, target: Path) -> bool:
+    """Create a symlink from target to source.
+
+    Args:
+        source: The actual file/directory (symlink target).
+        target: The symlink path to create.
+
+    Returns:
+        True if successful, False otherwise.
+    """
+    # Ensure parent directory exists
+    ensure_dir(target.parent)
+
+    # Remove existing symlink if present
+    if target.is_symlink():
+        target.unlink()
+    elif target.exists():
+        # Don't overwrite non-symlink files
+        return False
+
+    # Create relative symlink
+    try:
+        # Calculate relative path from target to source
+        rel_path = os.path.relpath(source, target.parent)
+        target.symlink_to(rel_path)
+        return True
+    except OSError:
+        return False
+
+
+def remove_project_links(project_path: Path) -> None:
+    """Remove all symlinks in a project's .claude directory.
+
+    Args:
+        project_path: Path to the project directory.
+    """
+    claude_dir = project_path / ".claude"
+    if not claude_dir.exists():
+        return
+
+    for subdir in ["skills", "agents", "hooks", "rules"]:
+        subdir_path = claude_dir / subdir
+        if not subdir_path.exists():
+            continue
+
+        for item in subdir_path.iterdir():
+            if item.is_symlink():
+                item.unlink()
+
+
+def update_component_gitignore(component_dir: Path, symlinked_names: list[str]) -> None:
+    """Update the .gitignore file in a component directory to ignore only symlinks.
+
+    This allows project-specific components to be committed while shared
+    symlinked components are ignored.
+
+    Args:
+        component_dir: Path to the component directory (e.g., .claude/skills/).
+        symlinked_names: List of symlinked component names to ignore.
+    """
+    gitignore_path = component_dir / ".gitignore"
+
+    if not symlinked_names:
+        # No symlinks, remove .gitignore if it exists and only has our content
+        if gitignore_path.exists():
+            content = gitignore_path.read_text()
+            if content.startswith("# CLDPM shared components"):
+                gitignore_path.unlink()
+        return
+
+    # Generate .gitignore content
+    lines = [
+        "# CLDPM shared components (symlinks to shared/)",
+        "# These are regenerated via 'cldpm sync' - do not commit symlinks",
+        "# Project-specific components in this directory WILL be committed",
+        "",
+    ]
+    lines.extend(sorted(symlinked_names))
+    lines.append("")  # Trailing newline
+
+    gitignore_path.write_text("\n".join(lines))
+
+
+def sync_project_links(
+    project_path: Path, repo_root: Optional[Path] = None
+) -> dict[str, list[str]]:
+    """Synchronize symlinks for a project based on its dependencies.
+
+    Args:
+        project_path: Path to the project directory.
+        repo_root: Path to the repo root. If None, will search for it.
+
+    Returns:
+        Dictionary with lists of created, failed, and skipped links.
+    """
+    if repo_root is None:
+        repo_root = find_repo_root(project_path)
+        if repo_root is None:
+            raise ValueError("Not in a CLDPM mono repo")
+
+    cldpm_config = load_cldpm_config(repo_root)
+    project_config = load_project_config(project_path)
+
+    shared_dir = repo_root / cldpm_config.shared_dir
+    claude_dir = project_path / ".claude"
+
+    result = {"created": [], "failed": [], "skipped": [], "missing": []}
+
+    # Process each dependency type
+    dep_types = [
+        ("skills", project_config.dependencies.skills),
+        ("agents", project_config.dependencies.agents),
+        ("hooks", project_config.dependencies.hooks),
+        ("rules", project_config.dependencies.rules),
+    ]
+
+    for dep_type, deps in dep_types:
+        target_dir = claude_dir / dep_type
+        ensure_dir(target_dir)
+
+        # Track successfully created symlinks for .gitignore
+        symlinked_names = []
+
+        for dep_name in deps:
+            source = shared_dir / dep_type / dep_name
+            target = target_dir / dep_name
+
+            if not source.exists():
+                result["missing"].append(f"{dep_type}/{dep_name}")
+                continue
+
+            if target.exists() and not target.is_symlink():
+                # Local component exists with same name - skip but warn
+                result["skipped"].append(f"{dep_type}/{dep_name}")
+                continue
+
+            if create_symlink(source, target):
+                result["created"].append(f"{dep_type}/{dep_name}")
+                symlinked_names.append(dep_name)
+            else:
+                result["failed"].append(f"{dep_type}/{dep_name}")
+
+        # Also include existing symlinks that weren't just created
+        for item in target_dir.iterdir():
+            if item.is_symlink() and item.name not in symlinked_names:
+                symlinked_names.append(item.name)
+
+        # Update .gitignore in this component directory
+        update_component_gitignore(target_dir, symlinked_names)
+
+    return result
+
+
+def add_component_link(
+    project_path: Path,
+    component_type: str,
+    component_name: str,
+    repo_root: Optional[Path] = None,
+) -> bool:
+    """Add a single component symlink to a project.
+
+    Args:
+        project_path: Path to the project directory.
+        component_type: Type of component (skills, agents, hooks, rules).
+        component_name: Name of the component.
+        repo_root: Path to the repo root. If None, will search for it.
+
+    Returns:
+        True if successful, False otherwise.
+    """
+    if repo_root is None:
+        repo_root = find_repo_root(project_path)
+        if repo_root is None:
+            raise ValueError("Not in a CLDPM mono repo")
+
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    source = shared_dir / component_type / component_name
+    target = project_path / ".claude" / component_type / component_name
+
+    if not source.exists():
+        return False
+
+    success = create_symlink(source, target)
+
+    if success:
+        # Update .gitignore in the component directory
+        component_dir = project_path / ".claude" / component_type
+        symlinked_names = [
+            item.name for item in component_dir.iterdir() if item.is_symlink()
+        ]
+        update_component_gitignore(component_dir, symlinked_names)
+
+    return success
+
+
+def get_local_components(project_path: Path) -> dict[str, list[str]]:
+    """Get list of local (non-symlinked) components in a project.
+
+    Args:
+        project_path: Path to the project directory.
+
+    Returns:
+        Dictionary mapping component types to lists of local component names.
+    """
+    claude_dir = project_path / ".claude"
+    result = {}
+
+    for component_type in ["skills", "agents", "hooks", "rules"]:
+        type_dir = claude_dir / component_type
+        if not type_dir.exists():
+            result[component_type] = []
+            continue
+
+        local_components = []
+        for item in type_dir.iterdir():
+            # Skip .gitignore and symlinks
+            if item.name == ".gitignore":
+                continue
+            if not item.is_symlink():
+                local_components.append(item.name)
+
+        result[component_type] = sorted(local_components)
+
+    return result
+
+
+def get_shared_components(project_path: Path) -> dict[str, list[str]]:
+    """Get list of shared (symlinked) components in a project.
+
+    Args:
+        project_path: Path to the project directory.
+
+    Returns:
+        Dictionary mapping component types to lists of shared component names.
+    """
+    claude_dir = project_path / ".claude"
+    result = {}
+
+    for component_type in ["skills", "agents", "hooks", "rules"]:
+        type_dir = claude_dir / component_type
+        if not type_dir.exists():
+            result[component_type] = []
+            continue
+
+        shared_components = []
+        for item in type_dir.iterdir():
+            if item.is_symlink():
+                shared_components.append(item.name)
+
+        result[component_type] = sorted(shared_components)
+
+    return result