llm-ide-rules 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

llm_ide_rules/commands/download.py

@@ -1,18 +1,15 @@
 """Download command: Download LLM instruction files from GitHub repositories."""
 
-import logging
 import re
 import tempfile
 import zipfile
 from pathlib import Path
-from typing import List
 
 import requests
-import structlog
 import typer
 from typing_extensions import Annotated
 
-logger = structlog.get_logger()
+from llm_ide_rules.log import log
 
 DEFAULT_REPO = "iloveitaly/llm-ide-rules"
 DEFAULT_BRANCH = "master"
@@ -20,7 +17,7 @@ DEFAULT_BRANCH = "master"
 
 def normalize_repo(repo: str) -> str:
     """Normalize repository input to user/repo format.
-    
+
     Handles both formats:
     - user/repo (unchanged)
     - https://github.com/user/repo/ (extracts user/repo)
@@ -28,17 +25,18 @@ def normalize_repo(repo: str) -> str:
     # If it's already in user/repo format, return as-is
     if "/" in repo and not repo.startswith("http"):
         return repo
-    
+
     # Extract user/repo from GitHub URL
     github_pattern = r"https?://github\.com/([^/]+/[^/]+)/?.*"
     match = re.match(github_pattern, repo)
-    
+
     if match:
         return match.group(1)
-    
+
     # If no pattern matches, assume it's already in the correct format
     return repo
 
+
 # Define what files/directories each instruction type includes
 INSTRUCTION_TYPES = {
     "cursor": {"directories": [".cursor"], "files": []},
@@ -47,8 +45,8 @@ INSTRUCTION_TYPES = {
         "files": [],
         "exclude_patterns": ["workflows/*"],
     },
-    "gemini": {"directories": [], "files": ["GEMINI.md"]},
-    "claude": {"directories": [], "files": ["CLAUDE.md"]},
+    "gemini": {"directories": [".gemini/commands"], "files": ["GEMINI.md"]},
+    "claude": {"directories": [".claude/commands"], "files": ["CLAUDE.md"]},
     "agent": {"directories": [], "files": ["AGENT.md"]},
     "agents": {"directories": [], "files": [], "recursive_files": ["AGENTS.md"]},
 }
@@ -62,13 +60,19 @@ def download_and_extract_repo(repo: str, branch: str = DEFAULT_BRANCH) -> Path:
     normalized_repo = normalize_repo(repo)
     zip_url = f"https://github.com/{normalized_repo}/archive/{branch}.zip"
 
-    logger.info("Downloading repository", repo=repo, normalized_repo=normalized_repo, branch=branch, url=zip_url)
+    log.info(
+        "downloading repository",
+        repo=repo,
+        normalized_repo=normalized_repo,
+        branch=branch,
+        url=zip_url,
+    )
 
     try:
         response = requests.get(zip_url, timeout=30)
         response.raise_for_status()
     except requests.RequestException as e:
-        logger.error("Failed to download repository", error=str(e), url=zip_url)
+        log.error("failed to download repository", error=str(e), url=zip_url)
         raise typer.Exit(1)
 
     # Create temporary directory and file
@@ -88,24 +92,24 @@ def download_and_extract_repo(repo: str, branch: str = DEFAULT_BRANCH) -> Path:
     # Find the extracted repository directory (should be the only directory)
     repo_dirs = [d for d in extract_dir.iterdir() if d.is_dir()]
     if not repo_dirs:
-        logger.error("No directories found in extracted ZIP")
+        log.error("no directories found in extracted zip")
         raise typer.Exit(1)
 
     repo_dir = repo_dirs[0]
-    logger.info("Repository extracted", path=str(repo_dir))
+    log.info("repository extracted", path=str(repo_dir))
 
     return repo_dir
 
 
 def copy_instruction_files(
-    repo_dir: Path, instruction_types: List[str], target_dir: Path
+    repo_dir: Path, instruction_types: list[str], target_dir: Path
 ):
     """Copy instruction files from the repository to the target directory."""
     copied_items = []
 
     for inst_type in instruction_types:
         if inst_type not in INSTRUCTION_TYPES:
-            logger.warning("Unknown instruction type", type=inst_type)
+            log.warning("unknown instruction type", type=inst_type)
             continue
 
         config = INSTRUCTION_TYPES[inst_type]
@@ -116,8 +120,8 @@ def copy_instruction_files(
             target_subdir = target_dir / dir_name
 
             if source_dir.exists():
-                logger.info(
-                    "Copying directory",
+                log.info(
+                    "copying directory",
                     source=str(source_dir),
                     target=str(target_subdir),
                 )
@@ -137,8 +141,8 @@ def copy_instruction_files(
             target_file = target_dir / file_name
 
             if source_file.exists():
-                logger.info(
-                    "Copying file", source=str(source_file), target=str(target_file)
+                log.info(
+                    "copying file", source=str(source_file), target=str(target_file)
                 )
 
                 # Create parent directories if needed
@@ -158,55 +162,53 @@ def copy_instruction_files(
 
 def copy_recursive_files(
     repo_dir: Path, target_dir: Path, file_pattern: str
-) -> List[str]:
+) -> list[str]:
     """Recursively copy files matching pattern, preserving directory structure.
-    
+
     Only copies files to locations where the target directory already exists.
     Warns and skips files where target directories don't exist.
-    
+
     Args:
         repo_dir: Source repository directory
         target_dir: Target directory to copy to
         file_pattern: File pattern to search for (e.g., "AGENTS.md")
-    
+
     Returns:
         List of copied file paths relative to target_dir
     """
     copied_items = []
-    
+
     # Find all matching files recursively
     matching_files = list(repo_dir.rglob(file_pattern))
-    
+
     for source_file in matching_files:
         # Calculate relative path from repo root
         relative_path = source_file.relative_to(repo_dir)
         target_file = target_dir / relative_path
-        
+
         # Check if target directory already exists
         target_parent = target_file.parent
         if not target_parent.exists():
-            logger.warning(
-                "Target directory does not exist, skipping file copy",
+            log.warning(
+                "target directory does not exist, skipping file copy",
                 target_directory=str(target_parent),
-                file=str(relative_path)
+                file=str(relative_path),
             )
             continue
-            
-        logger.info(
-            "Copying recursive file",
-            source=str(source_file),
-            target=str(target_file)
+
+        log.info(
+            "copying recursive file", source=str(source_file), target=str(target_file)
         )
-        
+
         # Copy file (parent directory already exists)
         target_file.write_bytes(source_file.read_bytes())
         copied_items.append(str(relative_path))
-    
+
     return copied_items
 
 
 def copy_directory_contents(
-    source_dir: Path, target_dir: Path, exclude_patterns: List[str]
+    source_dir: Path, target_dir: Path, exclude_patterns: list[str]
 ):
     """Recursively copy directory contents, excluding specified patterns."""
     for item in source_dir.rglob("*"):
@@ -216,6 +218,7 @@ def copy_directory_contents(
 
             # Check if file matches any exclude pattern
             should_exclude = False
+            pattern = ""
             for pattern in exclude_patterns:
                 if pattern.endswith("/*"):
                     # Pattern like "workflows/*" - exclude if path starts with "workflows/"
@@ -228,7 +231,7 @@ def copy_directory_contents(
                     break
 
             if should_exclude:
-                logger.debug("Excluding file", file=relative_str, pattern=pattern)
+                log.debug("excluding file", file=relative_str, pattern=pattern)
                 continue
 
             target_file = target_dir / relative_path
@@ -238,7 +241,7 @@ def copy_directory_contents(
 
 def download_main(
     instruction_types: Annotated[
-        List[str],
+        list[str] | None,
         typer.Argument(
             help="Types of instructions to download (cursor, github, gemini, claude, agent, agents). Downloads everything by default."
         ),
@@ -252,9 +255,6 @@ def download_main(
     target_dir: Annotated[
         str, typer.Option("--target", "-t", help="Target directory to download to")
     ] = ".",
-    verbose: Annotated[
-        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
-    ] = False,
 ):
     """Download LLM instruction files from GitHub repositories.
 
@@ -279,12 +279,6 @@ def download_main(
     # Download to a specific directory
     llm_ide_rules download --target ./my-project
     """
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-        structlog.configure(
-            wrapper_class=structlog.make_filtering_bound_logger(logging.DEBUG),
-        )
-
     # Use default types if none specified
     if not instruction_types:
         instruction_types = DEFAULT_TYPES
@@ -292,17 +286,19 @@ def download_main(
     # Validate instruction types
     invalid_types = [t for t in instruction_types if t not in INSTRUCTION_TYPES]
     if invalid_types:
-        logger.error(
-            "Invalid instruction types",
+        log.error(
+            "invalid instruction types",
             invalid_types=invalid_types,
             valid_types=list(INSTRUCTION_TYPES.keys()),
         )
+        error_msg = f"Invalid instruction types: {', '.join(invalid_types)}"
+        typer.echo(typer.style(error_msg, fg=typer.colors.RED), err=True)
         raise typer.Exit(1)
 
     target_path = Path(target_dir).resolve()
 
-    logger.info(
-        "Starting download",
+    log.info(
+        "starting download",
         repo=repo,
         branch=branch,
         instruction_types=instruction_types,
@@ -317,12 +313,12 @@ def download_main(
         copied_items = copy_instruction_files(repo_dir, instruction_types, target_path)
 
         if copied_items:
-            logger.info("Download completed successfully", copied_items=copied_items)
-            typer.echo(f"Downloaded {len(copied_items)} items to {target_path}:")
+            success_msg = f"Downloaded {len(copied_items)} items to {target_path}:"
+            typer.echo(typer.style(success_msg, fg=typer.colors.GREEN))
             for item in copied_items:
                 typer.echo(f"  - {item}")
         else:
-            logger.warning("No files were copied")
+            log.warning("no files were copied")
             typer.echo("No matching instruction files found in the repository.")
 
     finally: