cldpm 0.1.0__py3-none-any.whl

cldpm/commands/get.py

@@ -0,0 +1,375 @@
+"""Implementation of cldpm get command."""
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from ..core.config import load_cldpm_config
+from ..core.resolver import resolve_project
+from ..utils.fs import ensure_dir, find_repo_root
+from ..utils.git import (
+    cleanup_temp_dir,
+    clone_to_temp,
+    get_github_token,
+    parse_repo_url,
+)
+from ..utils.output import console, print_error, print_success, print_tree, print_warning
+
+
+@click.command()
+@click.argument("path_or_name")
+@click.option(
+    "--format",
+    "-f",
+    "output_format",
+    type=click.Choice(["json", "tree"]),
+    default="tree",
+    help="Output format",
+)
+@click.option(
+    "--remote",
+    "-r",
+    "remote_url",
+    help="Git repository URL (uses GITHUB_TOKEN or GH_TOKEN env var for auth)",
+)
+@click.option(
+    "--download",
+    "-d",
+    is_flag=True,
+    help="Download/copy project with all dependencies to output directory",
+)
+@click.option(
+    "--output",
+    "-o",
+    "output_dir",
+    help="Output directory for download (default: project name)",
+)
+def get(
+    path_or_name: str,
+    output_format: str,
+    remote_url: Optional[str],
+    download: bool,
+    output_dir: Optional[str],
+) -> None:
+    """Get project info with all components (shared and local).
+
+    Shows both shared components (from shared/, symlinked) and local
+    components (project-specific, in .claude/).
+
+    \b
+    Output includes:
+      - Project config from project.json
+      - Shared components (symlinked from shared/)
+      - Local components (project-specific in .claude/)
+
+    \b
+    Download option (-d):
+      Works for both local and remote repos. Copies the project with
+      all dependencies resolved (shared components copied as files).
+
+    \b
+    Remote URL formats:
+      owner/repo                    - GitHub shorthand
+      github.com/owner/repo         - Without https://
+      https://github.com/owner/repo - Full URL
+
+    \b
+    Environment variables for private repos:
+      GITHUB_TOKEN or GH_TOKEN
+
+    \b
+    Examples:
+      cldpm get my-project                      # Show project info
+      cldpm get my-project -f json              # JSON output
+      cldpm get my-project -d                   # Download to ./my-project
+      cldpm get my-project -d -o ./copy         # Download to ./copy
+      cldpm get my-project -r owner/repo        # From remote
+      cldpm get my-project -r owner/repo -d     # Download remote
+    """
+    if remote_url:
+        _handle_remote_get(
+            path_or_name, output_format, remote_url, download, output_dir
+        )
+    else:
+        _handle_local_get(path_or_name, output_format, download, output_dir)
+
+
+def _handle_local_get(
+    path_or_name: str,
+    output_format: str,
+    download: bool,
+    output_dir: Optional[str],
+) -> None:
+    """Handle get command for local repositories."""
+    # 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:
+        result = resolve_project(path_or_name, repo_root)
+    except FileNotFoundError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    # Output in requested format
+    if output_format == "json":
+        click.echo(json.dumps(result, indent=2))
+    else:
+        print_tree(result)
+
+    # Download if requested
+    if download:
+        _download_local_project(result, repo_root, output_dir)
+
+
+def _download_local_project(
+    resolved: dict,
+    repo_root: Path,
+    output_dir: Optional[str],
+) -> None:
+    """Download/copy a local project with all dependencies resolved."""
+    source_path = Path(resolved["path"])
+    project_name = resolved["name"]
+
+    # Determine target directory
+    if output_dir:
+        target_path = Path(output_dir).resolve()
+    else:
+        target_path = Path.cwd() / project_name
+
+    if target_path.exists():
+        print_error(f"Target directory already exists: {target_path}")
+        raise SystemExit(1)
+
+    # Create target directory
+    ensure_dir(target_path)
+
+    # Load CLDPM config for shared directory path
+    cldpm_config = load_cldpm_config(repo_root)
+    shared_dir = repo_root / cldpm_config.shared_dir
+
+    # Copy project files
+    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
+                    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
+                        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=False)
+        else:
+            shutil.copy2(item, dest)
+
+    # Copy shared dependencies (resolve symlinks to actual files)
+    for dep_type in ["skills", "agents", "hooks", "rules"]:
+        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 source_comp.is_dir():
+                    shutil.copytree(source_comp, target_comp)
+                else:
+                    shutil.copy2(source_comp, target_comp)
+
+    # Count what was copied
+    shared_counts = {
+        dep_type: len(resolved["shared"].get(dep_type, []))
+        for dep_type in ["skills", "agents", "hooks", "rules"]
+    }
+    local_counts = {
+        dep_type: len(resolved["local"].get(dep_type, []))
+        for dep_type in ["skills", "agents", "hooks", "rules"]
+    }
+
+    print_success(f"Downloaded to {target_path}")
+
+    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}")
+
+
+def _handle_remote_get(
+    path_or_name: str,
+    output_format: str,
+    remote_url: str,
+    download: bool,
+    output_dir: Optional[str],
+) -> None:
+    """Handle get command for remote repositories."""
+    # Get GitHub token
+    token = get_github_token()
+    if not token:
+        print_warning(
+            "No GITHUB_TOKEN or GH_TOKEN found. Private repos may not be accessible."
+        )
+
+    # Parse the remote URL
+    try:
+        repo_url, _subpath, branch = parse_repo_url(remote_url)
+    except ValueError as e:
+        print_error(str(e))
+        raise SystemExit(1)
+
+    temp_dir = None
+    try:
+        # Clone to temporary directory
+        console.print(f"[dim]Cloning {repo_url}...[/dim]")
+        temp_dir = clone_to_temp(repo_url, branch, token)
+
+        # Check if it's a valid CLDPM repo
+        if not (temp_dir / "cldpm.json").exists():
+            print_error("Remote repository is not a CLDPM mono repo (no cldpm.json found)")
+            raise SystemExit(1)
+
+        # Resolve the project
+        try:
+            result = resolve_project(path_or_name, temp_dir)
+        except FileNotFoundError as e:
+            print_error(str(e))
+            raise SystemExit(1)
+
+        # Add remote info to result
+        result["remote"] = {
+            "url": remote_url,
+            "repo_url": repo_url,
+            "branch": branch,
+        }
+
+        # Output the result
+        if output_format == "json":
+            click.echo(json.dumps(result, indent=2))
+        else:
+            print_tree(result)
+            console.print(f"\n[dim]Source: {remote_url}[/dim]")
+
+        # Download if requested
+        if download:
+            _download_remote_project(result, temp_dir, output_dir, repo_url)
+
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr if e.stderr else str(e)
+        if "Authentication failed" in error_msg or "could not read" in error_msg:
+            print_error(
+                "Authentication failed. Set GITHUB_TOKEN or GH_TOKEN environment variable."
+            )
+        else:
+            print_error(f"Git error: {error_msg}")
+        raise SystemExit(1)
+    finally:
+        # Clean up temp directory if not downloading
+        if temp_dir and not download:
+            cleanup_temp_dir(temp_dir)
+
+
+def _download_remote_project(
+    resolved: dict,
+    temp_dir: Path,
+    output_dir: Optional[str],
+    repo_url: str,
+) -> None:
+    """Download a remote project with all dependencies resolved."""
+    project_name = resolved["name"]
+
+    # Determine target directory
+    if output_dir:
+        target = Path(output_dir).resolve()
+    else:
+        target = Path.cwd() / project_name
+
+    if target.exists():
+        print_error(f"Target directory already exists: {target}")
+        raise SystemExit(1)
+
+    # For remote, we copy the resolved project (similar to local download)
+    # but from the temp directory
+    cldpm_config = load_cldpm_config(temp_dir)
+    shared_dir = temp_dir / cldpm_config.shared_dir
+    source_path = Path(resolved["path"])
+
+    # Create target directory
+    ensure_dir(target)
+
+    # Copy project files
+    for item in source_path.iterdir():
+        dest = target / item.name
+
+        if item.name == ".claude":
+            ensure_dir(dest)
+            for claude_item in item.iterdir():
+                claude_dest = dest / claude_item.name
+
+                if claude_item.name in ["skills", "agents", "hooks", "rules"]:
+                    ensure_dir(claude_dest)
+                    for comp_item in claude_item.iterdir():
+                        if comp_item.name == ".gitignore":
+                            continue
+                        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=False)
+        else:
+            shutil.copy2(item, dest)
+
+    # Copy shared dependencies
+    for dep_type in ["skills", "agents", "hooks", "rules"]:
+        for component in resolved["shared"].get(dep_type, []):
+            comp_name = component["name"]
+            source_comp = shared_dir / dep_type / comp_name
+            target_comp = target / ".claude" / dep_type / comp_name
+
+            if source_comp.exists() and not target_comp.exists():
+                if source_comp.is_dir():
+                    shutil.copytree(source_comp, target_comp)
+                else:
+                    shutil.copy2(source_comp, target_comp)
+
+    # Clean up temp directory
+    cleanup_temp_dir(temp_dir)
+
+    print_success(f"Downloaded to {target}")
+    console.print(f"  [dim]Source: {repo_url}[/dim]")

cldpm/commands/init.py

@@ -0,0 +1,331 @@
+"""Implementation of cldpm init command."""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+from jinja2 import Environment, PackageLoader
+
+from ..schemas import CldpmConfig, ProjectConfig, ProjectDependencies
+from ..core.config import save_cldpm_config, save_project_config
+from ..utils.fs import ensure_dir
+from ..utils.output import print_success, print_error, print_warning, print_dir_tree, console
+
+
+@click.command()
+@click.argument("directory", required=False, default=".")
+@click.option("--name", "-n", help="Name for the mono repo")
+@click.option(
+    "--existing",
+    "-e",
+    is_flag=True,
+    help="Initialize in an existing directory without overwriting files",
+)
+@click.option(
+    "--adopt-projects",
+    "-a",
+    "adopt_projects",
+    help="Adopt existing directories as projects (comma-separated paths or 'auto' to detect)",
+)
+@click.option(
+    "--projects-dir",
+    "-p",
+    "projects_dir",
+    default="projects",
+    help="Directory for projects (default: projects)",
+)
+@click.option(
+    "--shared-dir",
+    "-s",
+    "shared_dir",
+    default="shared",
+    help="Directory for shared components (default: shared)",
+)
+def init(
+    directory: str,
+    name: Optional[str],
+    existing: bool,
+    adopt_projects: Optional[str],
+    projects_dir: str,
+    shared_dir: str,
+) -> None:
+    """Initialize a new CLDPM mono repo.
+
+    Creates the directory structure and configuration files for managing
+    multiple Claude Code projects with shared and local components.
+
+    \b
+    Structure created:
+      shared/          - Shared components (skills, agents, hooks, rules)
+      projects/        - Individual projects
+      cldpm.json       - Mono repo configuration
+      CLAUDE.md        - Root instructions
+
+    \b
+    Examples:
+      cldpm init                              # Current directory
+      cldpm init my-monorepo                  # New directory
+      cldpm init --name "My Repo"             # Custom name
+      cldpm init -e                           # Existing repo, don't overwrite
+      cldpm init -e --adopt-projects auto     # Auto-detect existing projects
+      cldpm init -e -a "app,api"              # Adopt specific projects
+      cldpm init -p src -s common             # Custom directory names
+    """
+    # Resolve directory
+    repo_root = Path(directory).resolve()
+
+    # Check if already initialized
+    if (repo_root / "cldpm.json").exists():
+        if existing:
+            print_warning(f"CLDPM repo already exists at {repo_root}, updating...")
+        else:
+            print_error(f"CLDPM repo already exists at {repo_root}")
+            raise SystemExit(1)
+
+    # Check if directory exists and has content (for non-existing mode)
+    if not existing and repo_root.exists() and any(repo_root.iterdir()):
+        print_error(
+            f"Directory {repo_root} is not empty. Use --existing to initialize an existing repo."
+        )
+        raise SystemExit(1)
+
+    # Determine repo name
+    if name is None:
+        name = repo_root.name
+
+    # Create directory if needed
+    ensure_dir(repo_root)
+
+    # Create config
+    config = CldpmConfig(
+        name=name,
+        projectsDir=projects_dir,
+        sharedDir=shared_dir,
+    )
+    save_cldpm_config(config, repo_root)
+
+    # Create directory structure
+    dirs_to_create = [
+        f"{shared_dir}/skills",
+        f"{shared_dir}/agents",
+        f"{shared_dir}/hooks",
+        f"{shared_dir}/rules",
+        projects_dir,
+        ".cldpm/templates",
+    ]
+
+    for dir_path in dirs_to_create:
+        ensure_dir(repo_root / dir_path)
+
+    # Create templates using Jinja2
+    env = Environment(loader=PackageLoader("cldpm", "templates"))
+
+    # Create root CLAUDE.md (only if it doesn't exist or not in existing mode)
+    claude_md_path = repo_root / "CLAUDE.md"
+    if not existing or not claude_md_path.exists():
+        template = env.get_template("ROOT_CLAUDE.md.j2")
+        claude_md = template.render(repo_name=name)
+        claude_md_path.write_text(claude_md)
+
+    # Create/update .gitignore
+    gitignore_path = repo_root / ".gitignore"
+    if not existing or not gitignore_path.exists():
+        template = env.get_template("gitignore.j2")
+        gitignore = template.render()
+        gitignore_path.write_text(gitignore)
+    elif existing and gitignore_path.exists():
+        # Append CLDPM-specific entries if not already present
+        _update_gitignore(gitignore_path, projects_dir)
+
+    print_success(f"Initialized CLDPM mono repo: {name}")
+
+    # Adopt existing projects if requested
+    if adopt_projects:
+        adopted = _adopt_projects(repo_root, adopt_projects, projects_dir, env)
+        if adopted:
+            console.print(f"  Adopted {len(adopted)} project(s): {', '.join(adopted)}")
+
+    console.print()
+    print_dir_tree(repo_root, max_depth=2)
+
+
+def _update_gitignore(gitignore_path: Path, projects_dir: str) -> None:
+    """Update existing .gitignore with CLDPM-specific note."""
+    existing_content = gitignore_path.read_text()
+
+    # Check if CLDPM note already exists
+    if "CLDPM Note" in existing_content or "CLDPM shared components" in existing_content:
+        return
+
+    cldpm_note = """
+# CLDPM Note: Shared component symlinks are managed per-directory
+# Each .claude/{skills,agents,hooks,rules}/ has its own .gitignore
+# that only ignores symlinked shared components.
+# Project-specific components in those directories ARE committed.
+"""
+
+    # Append CLDPM note
+    with open(gitignore_path, "a") as f:
+        f.write(cldpm_note)
+
+
+def _adopt_projects(
+    repo_root: Path,
+    adopt_projects: str,
+    projects_dir: str,
+    env: Environment,
+) -> list[str]:
+    """Adopt existing directories as CLDPM projects.
+
+    Args:
+        repo_root: Path to the repo root.
+        adopt_projects: Comma-separated project paths or 'auto'.
+        projects_dir: Directory containing projects.
+        env: Jinja2 environment for templates.
+
+    Returns:
+        List of adopted project names.
+    """
+    adopted = []
+    projects_path = repo_root / projects_dir
+
+    if adopt_projects.lower() == "auto":
+        # Auto-detect: look for directories in projects_dir or repo root
+        candidates = []
+
+        # Check projects directory
+        if projects_path.exists():
+            candidates.extend(
+                [d for d in projects_path.iterdir() if d.is_dir() and not d.name.startswith(".")]
+            )
+
+        # If no projects_dir or it's empty, check repo root for potential projects
+        if not candidates:
+            for item in repo_root.iterdir():
+                if (
+                    item.is_dir()
+                    and not item.name.startswith(".")
+                    and item.name not in ["shared", "projects", ".cldpm", "node_modules", "__pycache__", "venv", ".venv"]
+                ):
+                    # Check if it looks like a project (has code or package files)
+                    if _looks_like_project(item):
+                        candidates.append(item)
+    else:
+        # Explicit project paths
+        candidates = []
+        for proj_path in adopt_projects.split(","):
+            proj_path = proj_path.strip()
+            if not proj_path:
+                continue
+
+            full_path = repo_root / proj_path
+            if full_path.exists() and full_path.is_dir():
+                candidates.append(full_path)
+            else:
+                print_warning(f"Project path not found: {proj_path}")
+
+    # Adopt each candidate
+    for candidate in candidates:
+        project_name = candidate.name
+
+        # Skip if already has project.json
+        if (candidate / "project.json").exists():
+            print_warning(f"Skipping {project_name}: already has project.json")
+            continue
+
+        # Create project.json
+        project_config = ProjectConfig(
+            name=project_name,
+            description=f"Adopted project: {project_name}",
+            dependencies=ProjectDependencies(),
+        )
+
+        # If project is not in projects_dir, we need to handle it
+        if candidate.parent != projects_path:
+            # Move to projects directory or create a reference
+            target_path = projects_path / project_name
+            if not target_path.exists():
+                # Create the project in projects_dir with a reference
+                ensure_dir(target_path)
+                save_project_config(project_config, target_path)
+                _setup_project_structure(target_path, env, project_name)
+
+                # Note: The original directory stays in place
+                # User may want to move files manually or set up differently
+                print_warning(
+                    f"Created project entry for {project_name}. "
+                    f"Original files remain at {candidate.relative_to(repo_root)}"
+                )
+            adopted.append(project_name)
+        else:
+            # Project is already in projects_dir
+            save_project_config(project_config, candidate)
+            _setup_project_structure(candidate, env, project_name)
+            adopted.append(project_name)
+
+    return adopted
+
+
+def _looks_like_project(path: Path) -> bool:
+    """Check if a directory looks like a project.
+
+    Looks for common project indicators like package files, source directories, etc.
+    """
+    indicators = [
+        "package.json",
+        "pyproject.toml",
+        "setup.py",
+        "Cargo.toml",
+        "go.mod",
+        "pom.xml",
+        "build.gradle",
+        "Makefile",
+        "CMakeLists.txt",
+        "src",
+        "lib",
+        "app",
+        "main.py",
+        "index.js",
+        "index.ts",
+        "CLAUDE.md",
+        ".claude",
+    ]
+
+    for indicator in indicators:
+        if (path / indicator).exists():
+            return True
+
+    return False
+
+
+def _setup_project_structure(
+    project_path: Path,
+    env: Environment,
+    project_name: str,
+) -> None:
+    """Set up the standard CLDPM project structure."""
+    # Create .claude directory structure
+    claude_dir = project_path / ".claude"
+    ensure_dir(claude_dir)
+    ensure_dir(claude_dir / "skills")
+    ensure_dir(claude_dir / "agents")
+    ensure_dir(claude_dir / "hooks")
+    ensure_dir(claude_dir / "rules")
+
+    # Create settings.json if it doesn't exist
+    settings_path = claude_dir / "settings.json"
+    if not settings_path.exists():
+        settings_path.write_text("{}\n")
+
+    # Create outputs directory
+    ensure_dir(project_path / "outputs")
+
+    # Create CLAUDE.md from template if it doesn't exist
+    claude_md_path = project_path / "CLAUDE.md"
+    if not claude_md_path.exists():
+        template = env.get_template("CLAUDE.md.j2")
+        claude_md = template.render(
+            project_name=project_name,
+            description="",
+        )
+        claude_md_path.write_text(claude_md)