cldpm 0.1.0__py3-none-any.whl

cldpm/commands/link.py

@@ -0,0 +1,320 @@
+"""Implementation of cldpm link command."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from ..core.config import load_cldpm_config, load_component_metadata
+from ..schemas import ComponentDependencies, ComponentMetadata
+from ..utils.fs import find_repo_root
+from ..utils.output import console, print_error, print_success, print_warning
+
+
+def parse_component_spec(spec: str) -> tuple[str, str]:
+    """Parse a component specification into type and name.
+
+    Args:
+        spec: Component spec like "skill:my-skill" or "skills:my-skill".
+
+    Returns:
+        Tuple of (component_type, component_name).
+
+    Raises:
+        ValueError: If format is invalid.
+    """
+    if ":" not in spec:
+        raise ValueError(
+            f"Invalid component format: '{spec}'. Use 'type:name' format (e.g., skill:my-skill)"
+        )
+
+    comp_type, comp_name = spec.split(":", 1)
+
+    # Normalize type to plural form
+    type_map = {
+        "skill": "skills",
+        "skills": "skills",
+        "agent": "agents",
+        "agents": "agents",
+        "hook": "hooks",
+        "hooks": "hooks",
+        "rule": "rules",
+        "rules": "rules",
+    }
+
+    if comp_type not in type_map:
+        raise ValueError(f"Unknown component type: {comp_type}")
+
+    return type_map[comp_type], comp_name
+
+
+def load_component_metadata_full(
+    comp_type: str, comp_name: str, repo_root: Path
+) -> tuple[Optional[ComponentMetadata], Path]:
+    """Load component metadata and return the metadata file path.
+
+    Args:
+        comp_type: Component type (skills, agents, hooks, rules).
+        comp_name: Component name.
+        repo_root: Path to the repo root.
+
+    Returns:
+        Tuple of (ComponentMetadata or None, metadata_file_path).
+    """
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    component_path = shared_dir / comp_type / comp_name
+    if not component_path.exists():
+        return None, component_path
+
+    singular_type = comp_type.rstrip("s")
+    metadata_path = component_path / f"{singular_type}.json"
+
+    if metadata_path.exists():
+        with open(metadata_path, "r") as f:
+            data = json.load(f)
+        return ComponentMetadata.model_validate(data), metadata_path
+
+    # Return minimal metadata if no file exists
+    return ComponentMetadata(name=comp_name), metadata_path
+
+
+def save_component_metadata(metadata: ComponentMetadata, metadata_path: Path) -> None:
+    """Save component metadata to a JSON file.
+
+    Args:
+        metadata: The ComponentMetadata to save.
+        metadata_path: Path to the metadata file.
+    """
+    data = {"name": metadata.name}
+
+    if metadata.description:
+        data["description"] = metadata.description
+
+    deps = metadata.dependencies
+    if deps.skills or deps.agents or deps.hooks or deps.rules:
+        data["dependencies"] = {}
+        if deps.skills:
+            data["dependencies"]["skills"] = deps.skills
+        if deps.agents:
+            data["dependencies"]["agents"] = deps.agents
+        if deps.hooks:
+            data["dependencies"]["hooks"] = deps.hooks
+        if deps.rules:
+            data["dependencies"]["rules"] = deps.rules
+
+    # Preserve any extra fields from the original
+    with open(metadata_path, "w") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+
+
+@click.command()
+@click.argument("dependencies")
+@click.option("--to", "-t", "target", required=True, help="Target component (type:name)")
+def link(dependencies: str, target: str) -> None:
+    """Link dependencies to an existing shared component.
+
+    Adds one or more components as dependencies of another component.
+    This updates the target component's metadata file.
+
+    \b
+    DEPENDENCIES format:
+      type:name              - Single dependency
+      type:a,type:b,type:c   - Multiple dependencies
+
+    \b
+    TARGET format:
+      type:name              - The component to add dependencies to
+
+    \b
+    Examples:
+      cldpm link skill:base-utils --to skill:advanced-review
+      cldpm link rule:security --to agent:security-audit
+      cldpm link skill:scan,skill:review,rule:security --to agent:auditor
+    """
+    # Find repo root
+    repo_root = find_repo_root()
+    if repo_root is None:
+        print_error("Not in a CLDPM mono repo. Run 'cldpm init' first.")
+        raise SystemExit(1)
+
+    # Parse target component
+    try:
+        target_type, target_name = parse_component_spec(target)
+    except ValueError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    # Load target component metadata
+    target_metadata, metadata_path = load_component_metadata_full(
+        target_type, target_name, repo_root
+    )
+
+    if target_metadata is None:
+        print_error(f"Target component not found: {target_type}/{target_name}")
+        raise SystemExit(1)
+
+    # Ensure metadata file exists
+    if not metadata_path.exists():
+        # Create minimal metadata file
+        metadata_path.parent.mkdir(parents=True, exist_ok=True)
+        target_metadata = ComponentMetadata(
+            name=target_name,
+            dependencies=ComponentDependencies(),
+        )
+
+    # Parse dependency specifications
+    dep_specs = [d.strip() for d in dependencies.split(",") if d.strip()]
+
+    if not dep_specs:
+        print_error("No dependencies specified")
+        raise SystemExit(1)
+
+    # Load CLDPM config to check if dependencies exist
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    # Process each dependency
+    added = []
+    already_linked = []
+    not_found = []
+
+    for dep_spec in dep_specs:
+        try:
+            dep_type, dep_name = parse_component_spec(dep_spec)
+        except ValueError as e:
+            print_error(str(e))
+            raise SystemExit(1)
+
+        # Check if dependency exists
+        dep_path = shared_dir / dep_type / dep_name
+        if not dep_path.exists():
+            not_found.append(f"{dep_type}/{dep_name}")
+            continue
+
+        # Get the appropriate dependency list
+        dep_list = getattr(target_metadata.dependencies, dep_type)
+
+        # Check if already linked
+        if dep_name in dep_list:
+            already_linked.append(f"{dep_type}/{dep_name}")
+            continue
+
+        # Add dependency
+        dep_list.append(dep_name)
+        added.append(f"{dep_type}/{dep_name}")
+
+    # Save updated metadata
+    if added:
+        save_component_metadata(target_metadata, metadata_path)
+        print_success(f"Linked dependencies to {target_type}/{target_name}")
+        for dep in added:
+            console.print(f"  [green]✓[/green] {dep}")
+
+    if already_linked:
+        print_warning("Already linked:")
+        for dep in already_linked:
+            console.print(f"  [dim]-[/dim] {dep}")
+
+    if not_found:
+        print_error("Dependencies not found:")
+        for dep in not_found:
+            console.print(f"  [red]✗[/red] {dep}")
+        if not added:
+            raise SystemExit(1)
+
+
+@click.command()
+@click.argument("dependencies")
+@click.option("--from", "-f", "target", required=True, help="Target component (type:name)")
+def unlink(dependencies: str, target: str) -> None:
+    """Remove dependencies from an existing shared component.
+
+    Removes one or more components as dependencies of another component.
+    This updates the target component's metadata file.
+
+    \b
+    DEPENDENCIES format:
+      type:name              - Single dependency
+      type:a,type:b,type:c   - Multiple dependencies
+
+    \b
+    TARGET format:
+      type:name              - The component to remove dependencies from
+
+    \b
+    Examples:
+      cldpm unlink skill:base-utils --from skill:advanced-review
+      cldpm unlink rule:security --from agent:security-audit
+      cldpm unlink skill:scan,skill:review --from agent:auditor
+    """
+    # Find repo root
+    repo_root = find_repo_root()
+    if repo_root is None:
+        print_error("Not in a CLDPM mono repo. Run 'cldpm init' first.")
+        raise SystemExit(1)
+
+    # Parse target component
+    try:
+        target_type, target_name = parse_component_spec(target)
+    except ValueError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    # Load target component metadata
+    target_metadata, metadata_path = load_component_metadata_full(
+        target_type, target_name, repo_root
+    )
+
+    if target_metadata is None:
+        print_error(f"Target component not found: {target_type}/{target_name}")
+        raise SystemExit(1)
+
+    if not metadata_path.exists():
+        print_error(f"No metadata file for: {target_type}/{target_name}")
+        raise SystemExit(1)
+
+    # Parse dependency specifications
+    dep_specs = [d.strip() for d in dependencies.split(",") if d.strip()]
+
+    if not dep_specs:
+        print_error("No dependencies specified")
+        raise SystemExit(1)
+
+    # Process each dependency
+    removed = []
+    not_linked = []
+
+    for dep_spec in dep_specs:
+        try:
+            dep_type, dep_name = parse_component_spec(dep_spec)
+        except ValueError as e:
+            print_error(str(e))
+            raise SystemExit(1)
+
+        # Get the appropriate dependency list
+        dep_list = getattr(target_metadata.dependencies, dep_type)
+
+        # Check if linked
+        if dep_name not in dep_list:
+            not_linked.append(f"{dep_type}/{dep_name}")
+            continue
+
+        # Remove dependency
+        dep_list.remove(dep_name)
+        removed.append(f"{dep_type}/{dep_name}")
+
+    # Save updated metadata
+    if removed:
+        save_component_metadata(target_metadata, metadata_path)
+        print_success(f"Unlinked dependencies from {target_type}/{target_name}")
+        for dep in removed:
+            console.print(f"  [green]✓[/green] {dep}")
+
+    if not_linked:
+        print_warning("Not linked (skipped):")
+        for dep in not_linked:
+            console.print(f"  [dim]-[/dim] {dep}")

cldpm/commands/remove.py

@@ -0,0 +1,289 @@
+"""Implementation of cldpm remove command."""
+
+from pathlib import Path
+
+import click
+
+from ..core.config import (
+    get_project_path,
+    load_cldpm_config,
+    load_project_config,
+    save_project_config,
+)
+from ..core.linker import update_component_gitignore
+from ..core.resolver import get_all_dependencies_for_component
+from ..utils.fs import find_repo_root
+from ..utils.output import console, print_error, print_success, print_warning
+
+
+def parse_component(component: str, repo_root: Path) -> tuple[str, str]:
+    """Parse a component specification into type and name.
+
+    Args:
+        component: Component spec like "skill:my-skill" or just "my-skill".
+        repo_root: Path to the repo root for auto-detection.
+
+    Returns:
+        Tuple of (component_type, component_name).
+
+    Raises:
+        ValueError: If component type cannot be determined.
+    """
+    if ":" in component:
+        comp_type, comp_name = component.split(":", 1)
+        type_map = {
+            "skill": "skills",
+            "skills": "skills",
+            "agent": "agents",
+            "agents": "agents",
+            "hook": "hooks",
+            "hooks": "hooks",
+            "rule": "rules",
+            "rules": "rules",
+        }
+        if comp_type not in type_map:
+            raise ValueError(f"Unknown component type: {comp_type}")
+        return type_map[comp_type], comp_name
+
+    # Auto-detect from project dependencies
+    raise ValueError(
+        f"Component '{component}' type not specified. Use 'type:name' format."
+    )
+
+
+def get_component_dependents(
+    comp_type: str,
+    comp_name: str,
+    project_path: Path,
+    repo_root: Path,
+) -> list[tuple[str, str]]:
+    """Find components in the project that depend on the given component.
+
+    Args:
+        comp_type: Component type being removed.
+        comp_name: Component name being removed.
+        project_path: Path to the project directory.
+        repo_root: Path to the repo root.
+
+    Returns:
+        List of (comp_type, comp_name) tuples that depend on this component.
+    """
+    project_config = load_project_config(project_path)
+    dependents = []
+
+    # Check all components in the project
+    for check_type in ["skills", "agents", "hooks", "rules"]:
+        check_list = getattr(project_config.dependencies, check_type)
+        for check_name in check_list:
+            if check_type == comp_type and check_name == comp_name:
+                continue
+
+            # Get dependencies of this component
+            deps = get_all_dependencies_for_component(check_type, check_name, repo_root)
+            dep_list = deps.get(comp_type, [])
+
+            if comp_name in dep_list:
+                dependents.append((check_type, check_name))
+
+    return dependents
+
+
+def find_orphaned_dependencies(
+    comp_type: str,
+    comp_name: str,
+    project_path: Path,
+    repo_root: Path,
+) -> list[tuple[str, str]]:
+    """Find dependencies that would become orphaned after removal.
+
+    A dependency is orphaned if no other component in the project uses it.
+
+    Args:
+        comp_type: Component type being removed.
+        comp_name: Component name being removed.
+        project_path: Path to the project directory.
+        repo_root: Path to the repo root.
+
+    Returns:
+        List of (comp_type, comp_name) tuples that would be orphaned.
+    """
+    project_config = load_project_config(project_path)
+
+    # Get dependencies of the component being removed
+    removed_deps = get_all_dependencies_for_component(comp_type, comp_name, repo_root)
+
+    orphaned = []
+
+    for dep_type, dep_names in removed_deps.items():
+        for dep_name in dep_names:
+            # Check if any other component in the project uses this dependency
+            is_used = False
+
+            for check_type in ["skills", "agents", "hooks", "rules"]:
+                check_list = getattr(project_config.dependencies, check_type)
+                for check_name in check_list:
+                    # Skip the component being removed
+                    if check_type == comp_type and check_name == comp_name:
+                        continue
+
+                    # Skip the dependency itself (it's a direct dependency)
+                    if check_type == dep_type and check_name == dep_name:
+                        is_used = True
+                        break
+
+                    # Check if this component depends on the dependency
+                    check_deps = get_all_dependencies_for_component(
+                        check_type, check_name, repo_root
+                    )
+                    if dep_name in check_deps.get(dep_type, []):
+                        is_used = True
+                        break
+
+                if is_used:
+                    break
+
+            if not is_used:
+                orphaned.append((dep_type, dep_name))
+
+    return orphaned
+
+
+def remove_single_component(
+    comp_type: str,
+    comp_name: str,
+    project_path: Path,
+    repo_root: Path,
+) -> bool:
+    """Remove a single component from a project.
+
+    Args:
+        comp_type: Component type (skills, agents, hooks, rules).
+        comp_name: Component name.
+        project_path: Path to the project directory.
+        repo_root: Path to the repo root.
+
+    Returns:
+        True if removed successfully, False otherwise.
+    """
+    project_config = load_project_config(project_path)
+    deps_list = getattr(project_config.dependencies, comp_type)
+
+    if comp_name not in deps_list:
+        return False
+
+    # Remove from dependencies
+    deps_list.remove(comp_name)
+    save_project_config(project_config, project_path)
+
+    # Remove symlink
+    remove_component_link(project_path, comp_type, comp_name)
+
+    # Update gitignore
+    component_dir = project_path / ".claude" / comp_type
+    if component_dir.exists():
+        # Get remaining symlinks
+        remaining_symlinks = [
+            item.name
+            for item in component_dir.iterdir()
+            if item.is_symlink()
+        ]
+        update_component_gitignore(component_dir, remaining_symlinks)
+
+    return True
+
+
+def remove_component_link(project_path: Path, comp_type: str, comp_name: str) -> None:
+    """Remove a component symlink from a project.
+
+    Args:
+        project_path: Path to the project directory.
+        comp_type: Component type (skills, agents, hooks, rules).
+        comp_name: Component name.
+    """
+    link_path = project_path / ".claude" / comp_type / comp_name
+    if link_path.is_symlink():
+        link_path.unlink()
+
+
+@click.command()
+@click.argument("component")
+@click.option("--from", "-f", "project_name", required=True, help="Target project name")
+@click.option("--keep-deps", is_flag=True, help="Keep orphaned dependencies")
+@click.option("--force", is_flag=True, help="Remove even if other components depend on it")
+def remove(component: str, project_name: str, keep_deps: bool, force: bool) -> None:
+    """Remove a shared component from a project.
+
+    Removes the component from project.json and deletes the symlink.
+    By default, also offers to remove orphaned dependencies.
+
+    \b
+    COMPONENT format:
+      type:name    - Explicit type (skill, agent, hook, rule)
+
+    \b
+    Examples:
+      cldpm remove skill:my-skill --from my-project
+      cldpm remove agent:pentester -f my-project
+      cldpm remove skill:common --from my-project --keep-deps
+      cldpm remove skill:shared --from my-project --force
+    """
+    # Find repo root
+    repo_root = find_repo_root()
+    if repo_root is None:
+        print_error("Not in a CLDPM mono repo. Run 'cldpm init' first.")
+        raise SystemExit(1)
+
+    # Get project path
+    project_path = get_project_path(project_name, repo_root)
+    if project_path is None:
+        print_error(f"Project not found: {project_name}")
+        raise SystemExit(1)
+
+    # Parse component
+    try:
+        comp_type, comp_name = parse_component(component, repo_root)
+    except ValueError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    # Check if component is in project
+    project_config = load_project_config(project_path)
+    deps_list = getattr(project_config.dependencies, comp_type)
+
+    if comp_name not in deps_list:
+        print_error(f"Component not in project: {comp_type}/{comp_name}")
+        raise SystemExit(1)
+
+    # Check for dependents
+    dependents = get_component_dependents(comp_type, comp_name, project_path, repo_root)
+    if dependents and not force:
+        print_error(f"Cannot remove {comp_type}/{comp_name}: other components depend on it")
+        for dep_type, dep_name in dependents:
+            console.print(f"  - {dep_type}/{dep_name}")
+        console.print("\nUse --force to remove anyway.")
+        raise SystemExit(1)
+
+    # Find orphaned dependencies
+    orphaned = []
+    if not keep_deps:
+        orphaned = find_orphaned_dependencies(comp_type, comp_name, project_path, repo_root)
+
+    # Remove the main component
+    if remove_single_component(comp_type, comp_name, project_path, repo_root):
+        print_success(f"Removed {comp_type}/{comp_name} from {project_name}")
+    else:
+        print_error(f"Failed to remove {comp_type}/{comp_name}")
+        raise SystemExit(1)
+
+    # Handle orphaned dependencies
+    if orphaned:
+        console.print("\n[dim]Orphaned dependencies:[/dim]")
+        for dep_type, dep_name in orphaned:
+            console.print(f"  - {dep_type}/{dep_name}")
+
+        if click.confirm("\nRemove orphaned dependencies?", default=True):
+            for dep_type, dep_name in orphaned:
+                if remove_single_component(dep_type, dep_name, project_path, repo_root):
+                    console.print(f"  [green]✓[/green] Removed {dep_type}/{dep_name}")
+                else:
+                    console.print(f"  [yellow]![/yellow] Failed to remove {dep_type}/{dep_name}")

cldpm/commands/sync.py

@@ -0,0 +1,91 @@
+"""Implementation of cldpm sync command."""
+
+from typing import Optional
+
+import click
+
+from ..core.config import get_project_path, list_projects
+from ..core.linker import remove_project_links, sync_project_links
+from ..utils.fs import find_repo_root
+from ..utils.output import console, print_error, print_success, print_warning
+
+
+@click.command()
+@click.argument("project_name", required=False)
+@click.option("--all", "-a", "sync_all", is_flag=True, help="Sync all projects")
+def sync(project_name: Optional[str], sync_all: bool) -> None:
+    """Regenerate symlinks for shared components.
+
+    Recreates symlinks from project's .claude/ directories to shared/
+    based on dependencies in project.json. Also updates per-directory
+    .gitignore files to ignore only the symlinked components.
+
+    \b
+    When to use:
+      - After 'git clone' (symlinks aren't committed)
+      - After adding dependencies to project.json manually
+      - When symlinks are broken or missing
+
+    \b
+    Note: Local (project-specific) components are not affected.
+
+    \b
+    Examples:
+      cldpm sync my-project     # Single project
+      cldpm sync --all          # All projects
+      cldpm sync -a             # All projects (short)
+    """
+    # Find repo root
+    repo_root = find_repo_root()
+    if repo_root is None:
+        print_error("Not in a CLDPM mono repo. Run 'cldpm init' first.")
+        raise SystemExit(1)
+
+    # Determine which projects to sync
+    if sync_all:
+        projects = list_projects(repo_root)
+        if not projects:
+            print_warning("No projects found in mono repo")
+            return
+    elif project_name:
+        project_path = get_project_path(project_name, repo_root)
+        if project_path is None:
+            print_error(f"Project not found: {project_name}")
+            raise SystemExit(1)
+        projects = [project_path]
+    else:
+        print_error("Specify a project name or use --all to sync all projects")
+        raise SystemExit(1)
+
+    # Sync each project
+    for project_path in projects:
+        project_name = project_path.name
+
+        # Remove existing symlinks
+        remove_project_links(project_path)
+
+        # Create fresh symlinks
+        result = sync_project_links(project_path, repo_root)
+
+        # Report results
+        if result["created"]:
+            print_success(f"{project_name}: synced {len(result['created'])} links")
+            for link in result["created"]:
+                console.print(f"  [green]✓[/green] {link}")
+        elif not result["missing"] and not result["failed"]:
+            console.print(f"[dim]{project_name}: no dependencies to sync[/dim]")
+
+        if result["missing"]:
+            print_warning(f"{project_name}: {len(result['missing'])} missing components")
+            for link in result["missing"]:
+                console.print(f"  [yellow]![/yellow] {link}")
+
+        if result["failed"]:
+            print_error(f"{project_name}: {len(result['failed'])} failed links")
+            for link in result["failed"]:
+                console.print(f"  [red]✗[/red] {link}")
+
+        if result["skipped"]:
+            console.print(
+                f"  [dim]Skipped {len(result['skipped'])} existing files[/dim]"
+            )