cldpm 0.1.0__py3-none-any.whl

cldpm/__init__.py

@@ -0,0 +1,12 @@
+"""CLDPM - Claude Project Manager.
+
+An SDK and CLI for managing mono repos with multiple Claude Code projects.
+
+Crafted by Transilience.ai
+Authored by Aman Agarwal (https://github.com/amanagarwal041)
+"""
+
+__version__ = "0.1.0"
+__author__ = "Aman Agarwal"
+__author_url__ = "https://github.com/amanagarwal041"
+__crafted_by__ = "Transilience.ai"

cldpm/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running cldpm as a module."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

cldpm/_banner.py

@@ -0,0 +1,99 @@
+"""CLDPM Banner Display Module.
+
+Displays decorative information about CLDPM, author, and Transilience.
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+BANNER_ASCII = r"""
+    ██████╗██╗     ██████╗ ██████╗ ███╗   ███╗
+   ██╔════╝██║     ██╔══██╗██╔══██╗████╗ ████║
+   ██║     ██║     ██║  ██║██████╔╝██╔████╔██║
+   ██║     ██║     ██║  ██║██╔═══╝ ██║╚██╔╝██║
+   ╚██████╗███████╗██████╔╝██║     ██║ ╚═╝ ██║
+    ╚═════╝╚══════╝╚═════╝ ╚═╝     ╚═╝     ╚═╝
+"""
+
+
+def print_banner(console: Console | None = None) -> None:
+    """Print the CLDPM installation/info banner."""
+    if console is None:
+        console = Console()
+
+    # ASCII art
+    ascii_text = Text(BANNER_ASCII, style="bold magenta")
+    console.print(ascii_text)
+
+    # Title
+    console.print("  [bold cyan]Claude Project Manager[/bold cyan]")
+    console.print("  [dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]")
+    console.print()
+
+    # Description
+    console.print("  [white]Manage mono repos with multiple Claude Code[/white]")
+    console.print("  [white]projects. Share skills, agents, hooks, and[/white]")
+    console.print("  [white]rules across projects without duplication.[/white]")
+    console.print()
+    console.print("  [dim]─────────────────────────────────────────[/dim]")
+    console.print()
+
+    # Quick Start
+    console.print("  [yellow]Quick Start:[/yellow]")
+    console.print("  [dim]$[/dim] [white]cldpm init my-monorepo[/white]")
+    console.print("  [dim]$[/dim] [white]cldpm create project web-app[/white]")
+    console.print("  [dim]$[/dim] [white]cldpm create skill logging[/white]")
+    console.print("  [dim]$[/dim] [white]cldpm add skill:logging --to web-app[/white]")
+    console.print()
+    console.print("  [dim]─────────────────────────────────────────[/dim]")
+    console.print()
+
+    # Attribution
+    console.print("  [magenta]◆[/magenta] [dim]Crafted by[/dim] [cyan]Transilience.ai[/cyan]")
+    console.print("  [magenta]◆[/magenta] [dim]Authored by[/dim] [white]Aman Agarwal[/white]")
+    console.print("    [dim]github.com/amanagarwal041[/dim]")
+    console.print()
+    console.print("  [dim]─────────────────────────────────────────[/dim]")
+    console.print()
+
+    # Links
+    console.print("  [dim]Docs:[/dim]    [cyan]https://cldpm.transilience.ai[/cyan]")
+    console.print("  [dim]GitHub:[/dim]  [cyan]https://github.com/transilienceai/cldpm[/cyan]")
+    console.print()
+    console.print("  [dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]")
+    console.print()
+
+
+def get_banner_text() -> str:
+    """Get banner as plain text for non-TTY environments."""
+    return f"""
+{BANNER_ASCII}
+  Claude Project Manager
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Manage mono repos with multiple Claude Code
+  projects. Share skills, agents, hooks, and
+  rules across projects without duplication.
+
+  ─────────────────────────────────────────
+
+  Quick Start:
+  $ cldpm init my-monorepo
+  $ cldpm create project web-app
+  $ cldpm create skill logging
+  $ cldpm add skill:logging --to web-app
+
+  ─────────────────────────────────────────
+
+  ◆ Crafted by Transilience.ai
+  ◆ Authored by Aman Agarwal
+    github.com/amanagarwal041
+
+  ─────────────────────────────────────────
+
+  Docs:    https://cldpm.transilience.ai
+  GitHub:  https://github.com/transilienceai/cldpm
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""

cldpm/cli.py

@@ -0,0 +1,81 @@
+"""CLI entry point for CLDPM."""
+
+import click
+
+from .commands import init, create, add, remove, link, unlink, get, clone, sync
+from ._banner import print_banner
+
+
+def show_version(ctx: click.Context, param: click.Parameter, value: bool) -> None:
+    """Custom version callback that shows banner."""
+    if not value or ctx.resilient_parsing:
+        return
+    print_banner()
+    ctx.exit()
+
+
+@click.group()
+@click.option(
+    "--version", "-v",
+    is_flag=True,
+    callback=show_version,
+    expose_value=False,
+    is_eager=True,
+    help="Show version and info banner.",
+)
+def cli() -> None:
+    """CLDPM - Claude Project Manager.
+
+    An SDK and CLI for managing mono repos with multiple Claude Code projects.
+    Supports both shared components (reusable across projects) and local
+    components (project-specific).
+
+    \b
+    Component Types:
+      - Shared: Stored in shared/, symlinked to projects, reusable
+      - Local:  Stored in .claude/, project-specific, committed directly
+
+    \b
+    Quick Start:
+      cldpm init my-monorepo              # Create new mono repo
+      cldpm create project my-app         # Create new project
+      cldpm add skill:common --to my-app  # Add shared component
+      cldpm get my-app                    # View project info
+      cldpm clone my-app ./standalone     # Export with all deps
+      cldpm sync --all                    # Restore symlinks after git clone
+
+    \b
+    Crafted by Transilience.ai
+    Authored by Aman Agarwal (https://github.com/amanagarwal041)
+    """
+    pass
+
+
+# Register commands
+cli.add_command(init)
+cli.add_command(create)
+cli.add_command(add)
+cli.add_command(remove)
+cli.add_command(link)
+cli.add_command(unlink)
+cli.add_command(get)
+cli.add_command(clone)
+cli.add_command(sync)
+
+
+@cli.command()
+def info() -> None:
+    """Show CLDPM information banner.
+
+    Displays version, quick start guide, and attribution.
+    """
+    print_banner()
+
+
+def main() -> None:
+    """Main entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

cldpm/commands/__init__.py

@@ -0,0 +1,12 @@
+"""CLI commands for CLDPM."""
+
+from .init import init
+from .create import create
+from .add import add
+from .remove import remove
+from .link import link, unlink
+from .get import get
+from .clone import clone
+from .sync import sync
+
+__all__ = ["init", "create", "add", "remove", "link", "unlink", "get", "clone", "sync"]

cldpm/commands/add.py

@@ -0,0 +1,206 @@
+"""Implementation of cldpm add command."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from ..core.config import (
+    get_project_path,
+    load_cldpm_config,
+    load_project_config,
+    save_project_config,
+)
+from ..core.linker import add_component_link
+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.
+    """
+    # Check for explicit type prefix
+    if ":" in component:
+        comp_type, comp_name = component.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
+
+    # Auto-detect type by searching shared directories
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    for comp_type in ["skills", "agents", "hooks", "rules"]:
+        if (shared_dir / comp_type / component).exists():
+            return comp_type, component
+
+    raise ValueError(
+        f"Component '{component}' not found. Use 'type:name' format or ensure it exists in shared/."
+    )
+
+
+def add_single_component(
+    comp_type: str,
+    comp_name: str,
+    project_path: Path,
+    repo_root: Path,
+    is_dependency: bool = False,
+) -> bool:
+    """Add a single component to 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.
+        is_dependency: Whether this is being added as a dependency.
+
+    Returns:
+        True if added successfully, False if already exists or failed.
+    """
+    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():
+        if is_dependency:
+            console.print(f"  [yellow]![/yellow] {comp_type}/{comp_name} (dependency not found)")
+        return False
+
+    # Load project config
+    project_config = load_project_config(project_path)
+    deps_list = getattr(project_config.dependencies, comp_type)
+
+    # Check if already added
+    if comp_name in deps_list:
+        return False
+
+    # Add to dependencies
+    deps_list.append(comp_name)
+    save_project_config(project_config, project_path)
+
+    # Create symlink
+    if add_component_link(project_path, comp_type, comp_name, repo_root):
+        if is_dependency:
+            console.print(f"  [green]✓[/green] {comp_type}/{comp_name} (dependency)")
+        return True
+    else:
+        if is_dependency:
+            console.print(f"  [yellow]![/yellow] {comp_type}/{comp_name} (symlink failed)")
+        return False
+
+
+@click.command()
+@click.argument("component")
+@click.option("--to", "-t", "project_name", required=True, help="Target project name")
+@click.option("--no-deps", is_flag=True, help="Skip installing component dependencies")
+def add(component: str, project_name: str, no_deps: bool) -> None:
+    """Add a shared component to a project.
+
+    Creates a symlink from the project's .claude/ directory to the shared
+    component, and updates project.json dependencies. The symlink is
+    automatically gitignored; only the reference in project.json is committed.
+
+    Components can have dependencies on other components. By default, all
+    dependencies are also added. Use --no-deps to skip dependencies.
+
+    \b
+    COMPONENT format:
+      type:name    - Explicit type (skill, agent, hook, rule)
+      name         - Auto-detect type from shared/ directory
+
+    \b
+    Note: For project-specific (local) components, create them directly in
+    projects/<name>/.claude/<type>/ - no 'cldpm add' needed.
+
+    \b
+    Examples:
+      cldpm add skill:my-skill --to my-project
+      cldpm add agent:pentester --to my-project
+      cldpm add hook:pre-commit -t my-project
+      cldpm add my-skill --to my-project          # Auto-detect type
+      cldpm add agent:security --to my-project --no-deps
+    """
+    # 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 exists
+    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():
+        print_error(f"Component not found: {comp_type}/{comp_name}")
+        raise SystemExit(1)
+
+    # Load project config to check if already added
+    project_config = load_project_config(project_path)
+    deps_list = getattr(project_config.dependencies, comp_type)
+
+    if comp_name in deps_list:
+        print_warning(f"Component already in project: {comp_type}/{comp_name}")
+        return
+
+    # Add the main component
+    deps_list.append(comp_name)
+    save_project_config(project_config, project_path)
+
+    # Create symlink
+    if add_component_link(project_path, comp_type, comp_name, repo_root):
+        print_success(f"Added {comp_type}/{comp_name} to {project_name}")
+    else:
+        print_warning(f"Added to config but failed to create symlink for {comp_type}/{comp_name}")
+
+    # Add dependencies if not skipped
+    if not no_deps:
+        all_deps = get_all_dependencies_for_component(comp_type, comp_name, repo_root)
+        deps_added = False
+
+        for dep_type, dep_names in all_deps.items():
+            for dep_name in dep_names:
+                if add_single_component(
+                    dep_type, dep_name, project_path, repo_root, is_dependency=True
+                ):
+                    deps_added = True
+
+        if not deps_added and any(all_deps.values()):
+            # Dependencies exist but were already added
+            pass

cldpm/commands/clone.py

@@ -0,0 +1,184 @@
+"""Implementation of cldpm clone command."""
+
+import json
+import shutil
+from pathlib import Path
+
+import click
+
+from ..core.config import load_cldpm_config, load_project_config
+from ..core.resolver import resolve_project
+from ..utils.fs import ensure_dir, find_repo_root
+from ..utils.output import console, print_error, print_success, print_dir_tree
+
+
+@click.command()
+@click.argument("project_name")
+@click.argument("directory")
+@click.option(
+    "--include-shared",
+    is_flag=True,
+    help="Also copy the full shared/ directory structure",
+)
+@click.option(
+    "--preserve-links",
+    is_flag=True,
+    help="Keep symlinks instead of copying (requires shared/ to exist)",
+)
+def clone(
+    project_name: str,
+    directory: str,
+    include_shared: bool,
+    preserve_links: bool,
+) -> None:
+    """Clone a project to a standalone directory with all dependencies.
+
+    Creates a complete, standalone copy of the project:
+      - Shared components: Resolved from symlinks, copied as actual files
+      - Local components: Copied directly
+
+    \b
+    Use cases:
+      - Export project to work outside the mono repo
+      - Share project with someone without the mono repo
+      - Create a snapshot with all dependencies
+
+    \b
+    Examples:
+      cldpm clone my-project ./standalone
+      cldpm clone my-project /path/to/output
+      cldpm clone my-project ./export --include-shared
+      cldpm clone my-project ./linked --preserve-links
+    """
+    # 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)
+
+    # Resolve project
+    try:
+        resolved = resolve_project(project_name, repo_root)
+    except FileNotFoundError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    # Get source project path
+    source_path = Path(resolved["path"])
+    target_path = Path(directory).resolve()
+
+    # Check if target exists
+    if target_path.exists():
+        print_error(f"Target directory already exists: {target_path}")
+        raise SystemExit(1)
+
+    # Create target directory
+    ensure_dir(target_path)
+
+    # Copy project files (excluding .claude subdirectories that are symlinks)
+    for item in source_path.iterdir():
+        dest = target_path / item.name
+
+        if item.name == ".claude":
+            # Handle .claude directory specially
+            ensure_dir(dest)
+            for claude_item in item.iterdir():
+                claude_dest = dest / claude_item.name
+
+                if claude_item.name in ["skills", "agents", "hooks", "rules"]:
+                    # Create directory, will be populated below
+                    ensure_dir(claude_dest)
+
+                    # Copy local (non-symlink) components directly
+                    for comp_item in claude_item.iterdir():
+                        if comp_item.name == ".gitignore":
+                            continue  # Skip .gitignore, will regenerate if needed
+                        if not comp_item.is_symlink():
+                            comp_dest = claude_dest / comp_item.name
+                            if comp_item.is_dir():
+                                shutil.copytree(comp_item, comp_dest)
+                            else:
+                                shutil.copy2(comp_item, comp_dest)
+                elif claude_item.is_file():
+                    shutil.copy2(claude_item, claude_dest)
+                elif claude_item.is_dir():
+                    shutil.copytree(claude_item, claude_dest)
+        elif item.is_dir():
+            shutil.copytree(item, dest, symlinks=preserve_links)
+        else:
+            shutil.copy2(item, dest)
+
+    # Copy shared dependencies
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    shared_counts = {}
+    for dep_type in ["skills", "agents", "hooks", "rules"]:
+        count = 0
+        for component in resolved["shared"].get(dep_type, []):
+            comp_name = component["name"]
+            source_comp = shared_dir / dep_type / comp_name
+            target_comp = target_path / ".claude" / dep_type / comp_name
+
+            if source_comp.exists() and not target_comp.exists():
+                if preserve_links:
+                    # Create symlink (will only work if shared/ is accessible)
+                    target_comp.symlink_to(source_comp)
+                else:
+                    # Copy actual files
+                    if source_comp.is_dir():
+                        shutil.copytree(source_comp, target_comp)
+                    else:
+                        shutil.copy2(source_comp, target_comp)
+                count += 1
+        shared_counts[dep_type] = count
+
+    # Count local components
+    local_counts = {
+        dep_type: len(resolved["local"].get(dep_type, []))
+        for dep_type in ["skills", "agents", "hooks", "rules"]
+    }
+
+    # Optionally copy full shared directory
+    if include_shared:
+        target_shared = target_path / "shared"
+        shutil.copytree(shared_dir, target_shared)
+
+        # Also copy cldpm.json for reference
+        shutil.copy2(repo_root / "cldpm.json", target_path / "cldpm.json")
+
+    # Update settings.json if it references hooks
+    settings_path = target_path / ".claude" / "settings.json"
+    if settings_path.exists():
+        try:
+            with open(settings_path) as f:
+                settings = json.load(f)
+
+            # Update any hook paths to be relative to the cloned project
+            # (This is a placeholder - actual hook path updates would depend on the hook format)
+
+            with open(settings_path, "w") as f:
+                json.dump(settings, f, indent=2)
+                f.write("\n")
+        except (json.JSONDecodeError, IOError):
+            pass  # Ignore settings.json issues
+
+    print_success(f"Cloned {project_name} to {target_path}")
+
+    # Show what was copied
+    non_zero_shared = {k: v for k, v in shared_counts.items() if v > 0}
+    non_zero_local = {k: v for k, v in local_counts.items() if v > 0}
+
+    if non_zero_shared:
+        deps_str = ", ".join(f"{v} {k}" for k, v in non_zero_shared.items())
+        console.print(f"  Shared: {deps_str}")
+
+    if non_zero_local:
+        deps_str = ", ".join(f"{v} {k}" for k, v in non_zero_local.items())
+        console.print(f"  Local: {deps_str}")
+
+    if include_shared:
+        console.print("  Included: full shared/ directory")
+
+    console.print()
+    print_dir_tree(target_path, max_depth=3)