pdd-cli 0.0.90__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/auth_service.py

@@ -0,0 +1,210 @@
+"""Shared authentication service for PDD Cloud.
+
+This module provides common authentication functions used by both:
+- REST API endpoints (pdd/server/routes/auth.py) for the web frontend
+- CLI commands (pdd/commands/auth.py) for terminal-based auth management
+
+By centralizing auth logic here, we ensure consistent behavior across interfaces.
+"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
+
+
+# JWT file cache path
+JWT_CACHE_FILE = Path.home() / ".pdd" / "jwt_cache"
+
+# Keyring configuration (must match app_name="PDD CLI" used in commands/auth.py)
+KEYRING_SERVICE_NAME = "firebase-auth-PDD CLI"
+KEYRING_USER_NAME = "refresh_token"
+
+
+def get_jwt_cache_info() -> Tuple[bool, Optional[float]]:
+    """
+    Check JWT cache file for valid token.
+
+    Returns:
+        Tuple of (is_valid, expires_at). If valid, expires_at is the timestamp
+        when the token expires. If invalid or not found, returns (False, None).
+    """
+    if not JWT_CACHE_FILE.exists():
+        return False, None
+
+    try:
+        with open(JWT_CACHE_FILE, "r") as f:
+            cache = json.load(f)
+        expires_at = cache.get("expires_at", 0)
+        # Check if token is still valid (with 5 minute buffer)
+        if expires_at > time.time() + 300:
+            return True, expires_at
+    except (json.JSONDecodeError, IOError, KeyError):
+        pass
+
+    return False, None
+
+
+def get_cached_jwt() -> Optional[str]:
+    """
+    Get the cached JWT token if it exists and is valid.
+
+    Returns:
+        The JWT token string if valid, None otherwise.
+    """
+    if not JWT_CACHE_FILE.exists():
+        return None
+
+    try:
+        with open(JWT_CACHE_FILE, "r") as f:
+            cache = json.load(f)
+        expires_at = cache.get("expires_at", 0)
+        # Check if token is still valid (with 5 minute buffer)
+        if expires_at > time.time() + 300:
+            # Check both 'id_token' (new) and 'jwt' (legacy) keys for backwards compatibility
+            return cache.get("id_token") or cache.get("jwt")
+    except (json.JSONDecodeError, IOError, KeyError):
+        pass
+
+    return None
+
+
+def has_refresh_token() -> bool:
+    """
+    Check if there's a stored refresh token in keyring.
+
+    Returns:
+        True if a refresh token exists, False otherwise.
+    """
+    try:
+        import keyring
+
+        token = keyring.get_password(KEYRING_SERVICE_NAME, KEYRING_USER_NAME)
+        return token is not None
+    except ImportError:
+        # Try alternative keyring
+        try:
+            import keyrings.alt.file
+
+            kr = keyrings.alt.file.PlaintextKeyring()
+            token = kr.get_password(KEYRING_SERVICE_NAME, KEYRING_USER_NAME)
+            return token is not None
+        except ImportError:
+            pass
+    except Exception:
+        pass
+
+    return False
+
+
+def clear_jwt_cache() -> Tuple[bool, Optional[str]]:
+    """
+    Clear the JWT cache file.
+
+    Returns:
+        Tuple of (success, error_message). If successful, error_message is None.
+    """
+    if not JWT_CACHE_FILE.exists():
+        return True, None
+
+    try:
+        JWT_CACHE_FILE.unlink()
+        return True, None
+    except Exception as e:
+        return False, f"Failed to clear JWT cache: {e}"
+
+
+def clear_refresh_token() -> Tuple[bool, Optional[str]]:
+    """
+    Clear the refresh token from keyring.
+
+    Returns:
+        Tuple of (success, error_message). If successful, error_message is None.
+    """
+    try:
+        import keyring
+
+        keyring.delete_password(KEYRING_SERVICE_NAME, KEYRING_USER_NAME)
+        return True, None
+    except ImportError:
+        # Try alternative keyring
+        try:
+            import keyrings.alt.file
+
+            kr = keyrings.alt.file.PlaintextKeyring()
+            kr.delete_password(KEYRING_SERVICE_NAME, KEYRING_USER_NAME)
+            return True, None
+        except ImportError:
+            return True, None  # No keyring available, nothing to clear
+        except Exception as e:
+            return False, f"Failed to clear refresh token: {e}"
+    except Exception as e:
+        error_str = str(e)
+        # Ignore "not found" errors - token was already deleted
+        if "not found" in error_str.lower() or "no matching" in error_str.lower():
+            return True, None
+        return False, f"Failed to clear refresh token: {e}"
+
+
+def get_auth_status() -> Dict[str, Any]:
+    """
+    Get current authentication status.
+
+    Returns:
+        Dict with keys:
+        - authenticated: bool - True if user has valid auth
+        - cached: bool - True if using cached JWT (vs refresh token)
+        - expires_at: Optional[float] - JWT expiration timestamp if cached
+    """
+    # First check JWT cache
+    cache_valid, expires_at = get_jwt_cache_info()
+    if cache_valid:
+        return {
+            "authenticated": True,
+            "cached": True,
+            "expires_at": expires_at,
+        }
+
+    # Check for refresh token in keyring
+    has_refresh = has_refresh_token()
+    if has_refresh:
+        return {
+            "authenticated": True,
+            "cached": False,
+            "expires_at": None,
+        }
+
+    return {
+        "authenticated": False,
+        "cached": False,
+        "expires_at": None,
+    }
+
+
+def logout() -> Tuple[bool, Optional[str]]:
+    """
+    Clear all authentication tokens (logout).
+
+    Clears both the JWT cache file and the refresh token from keyring.
+
+    Returns:
+        Tuple of (success, error_message). If any error occurred,
+        success is False and error_message contains the details.
+    """
+    errors = []
+
+    # Clear JWT cache
+    jwt_success, jwt_error = clear_jwt_cache()
+    if not jwt_success and jwt_error:
+        errors.append(jwt_error)
+
+    # Clear refresh token from keyring
+    refresh_success, refresh_error = clear_refresh_token()
+    if not refresh_success and refresh_error:
+        errors.append(refresh_error)
+
+    if errors:
+        return False, "; ".join(errors)
+
+    return True, None

pdd/auto_deps_main.py

@@ -1,40 +1,36 @@
-"""Main function for the auto-deps command."""
+from __future__ import annotations
 import sys
 from pathlib import Path
-from typing import Callable, Tuple, Optional
+from typing import Optional, Tuple, Callable
 import click
 from rich import print as rprint
+from filelock import FileLock
 
 from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .construct_paths import construct_paths
 from .insert_includes import insert_includes
 
-def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
+
+def auto_deps_main(
     ctx: click.Context,
     prompt_file: str,
     directory_path: str,
     auto_deps_csv_path: Optional[str],
     output: Optional[str],
-    force_scan: Optional[bool],
+    force_scan: Optional[bool] = False,
     progress_callback: Optional[Callable[[int, int], None]] = None
 ) -> Tuple[str, float, str]:
     """
-    Main function to analyze and insert dependencies into a prompt file.
-
-    Args:
-        ctx: Click context containing command-line parameters.
-        prompt_file: Path to the input prompt file.
-        directory_path: Path to directory containing potential dependency files.
-        auto_deps_csv_path: Path to CSV file containing auto-dependency information.
-        output: Optional path to save the modified prompt file.
-        force_scan: Flag to force rescan of directory by deleting CSV file.
-        progress_callback: Callback for progress updates (current, total) for each file.
+    Main function to analyze a prompt file and insert dependencies found in a directory.
 
-    Returns:
-        Tuple containing:
-        - str: Modified prompt with auto-dependencies added
-        - float: Total cost of the operation
-        - str: Name of the model used
+    :param ctx: Click context containing command-line parameters.
+    :param prompt_file: Path to the input prompt file.
+    :param directory_path: Path to the directory or glob pattern containing potential dependency files.
+    :param auto_deps_csv_path: Preferred CSV file path for dependency info (may be overridden by resolved paths).
+    :param output: File path (or directory) to save the modified prompt file.
+    :param force_scan: Flag to force a rescan by deleting the existing CSV cache.
+    :param progress_callback: Optional callback for progress updates (current, total).
+    :return: A tuple containing the modified prompt, total cost, and model name used.
     """
     try:
         # Construct file paths
@@ -45,7 +41,7 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
             "output": output,
             "csv": auto_deps_csv_path
         }
-
+        
         resolved_config, input_strings, output_file_paths, _ = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
@@ -56,50 +52,64 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
             confirm_callback=ctx.obj.get('confirm_callback')
         )
 
-        # Get the CSV file path
+        # Resolve CSV path
         csv_path = output_file_paths.get("csv", "project_dependencies.csv")
 
-        # Handle force_scan option
+        # Handle force scan option
         if force_scan and Path(csv_path).exists():
             if not ctx.obj.get('quiet', False):
-                rprint(
-                    "[yellow]Removing existing CSV file due to "
-                    f"--force-scan option: {csv_path}[/yellow]"
-                )
-            Path(csv_path).unlink()
+                rprint(f"[yellow]Removing existing CSV file due to --force-scan option: {csv_path}[/yellow]")
+            try:
+                Path(csv_path).unlink()
+            except OSError as e:
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[yellow]Warning: Could not delete CSV file: {e}[/yellow]")
 
-        # Get strength and temperature from context
-        strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
-        temperature = ctx.obj.get('temperature', 0)
-        time_budget = ctx.obj.get('time', DEFAULT_TIME)
+        # Acquire lock to prevent concurrent access to the CSV cache
+        lock_path = f"{csv_path}.lock"
+        lock = FileLock(lock_path)
+        
+        with lock:
+            # Load input file
+            prompt_content = input_strings["prompt_file"]
 
-        # Call insert_includes with the prompt content and directory path
-        modified_prompt, csv_output, total_cost, model_name = insert_includes(
-            input_prompt=input_strings["prompt_file"],
-            directory_path=directory_path,
-            csv_filename=csv_path,
-            prompt_filename=prompt_file,
-            strength=strength,
-            temperature=temperature,
-            time=time_budget,
-            verbose=not ctx.obj.get('quiet', False),
-            progress_callback=progress_callback
-        )
+            # Get LLM parameters
+            strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
+            temperature = ctx.obj.get('temperature', 0.0)
+            time_budget = ctx.obj.get('time', DEFAULT_TIME)
+            verbose = not ctx.obj.get('quiet', False)
+
+            # Run the dependency analysis and insertion
+            modified_prompt, csv_output, total_cost, model_name = insert_includes(
+                input_prompt=prompt_content,
+                directory_path=directory_path,
+                csv_filename=csv_path,
+                prompt_filename=prompt_file,
+                strength=strength,
+                temperature=temperature,
+                time=time_budget,
+                verbose=verbose,
+                progress_callback=progress_callback
+            )
 
-        # Save the modified prompt to the output file
-        output_path = output_file_paths["output"]
-        Path(output_path).write_text(modified_prompt, encoding="utf-8")
+            # Save the modified prompt
+            output_path = output_file_paths["output"]
+            if output_path:
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(modified_prompt)
 
-        # Save the CSV output if it was generated
-        if csv_output:
-            Path(csv_path).write_text(csv_output, encoding="utf-8")
+            # Save the CSV output if content exists
+            if csv_output:
+                with open(csv_path, 'w', encoding='utf-8') as f:
+                    f.write(csv_output)
 
         # Provide user feedback
         if not ctx.obj.get('quiet', False):
             rprint("[bold green]Successfully analyzed and inserted dependencies![/bold green]")
             rprint(f"[bold]Model used:[/bold] {model_name}")
             rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
-            rprint(f"[bold]Modified prompt saved to:[/bold] {output_path}")
+            if output_path:
+                rprint(f"[bold]Modified prompt saved to:[/bold] {output_path}")
             rprint(f"[bold]Dependency information saved to:[/bold] {csv_path}")
 
         return modified_prompt, total_cost, model_name
@@ -107,8 +117,8 @@ def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
     except click.Abort:
         # User cancelled - re-raise to stop the sync loop
         raise
-    except Exception as exc:
+    except Exception as e:
         if not ctx.obj.get('quiet', False):
-            rprint(f"[bold red]Error:[/bold red] {str(exc)}")
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
         # Return error result instead of sys.exit(1) to allow orchestrator to handle gracefully
-        return "", 0.0, f"Error: {exc}"
+        return "", 0.0, f"Error: {e}"

pdd/auto_include.py

@@ -4,7 +4,8 @@ insert dependencies into a prompt.
 """
 import re
 from io import StringIO
-from typing import Callable, Tuple, Optional
+from pathlib import Path
+from typing import Callable, List, Optional, Set, Tuple
 
 import pandas as pd
 from pydantic import BaseModel, Field
@@ -151,11 +152,175 @@ def _filter_self_references(dependencies: str, module_name: Optional[str]) -> st
     """
     if not module_name:
         return dependencies
-    # Pattern matches: <...><include>context/{module_name}_example.py</include></...>
-    pattern = rf'<[^>]+><include>context/{re.escape(module_name)}_example\.py</include></[^>]+>\s*'
+    # Pattern matches: <...><include>context/[subdirs/]{module_name}_example.py</include></...>
+    # The (?:[^/]+/)* matches zero or more subdirectory levels (e.g., backend/, frontend/)
+    pattern = rf'<[^>]+><include>context/(?:[^/]+/)*{re.escape(module_name)}_example\.py</include></[^>]+>\s*'
     return re.sub(pattern, '', dependencies)
 
 
+def _fix_malformed_includes(dependencies: str) -> str:
+    """Fix malformed [File: ...] patterns to proper <include>...</include> format.
+
+    The LLM sometimes outputs [File: path] instead of <include>path</include>.
+    This function corrects that error.
+
+    Args:
+        dependencies: The dependencies string containing potential malformed includes.
+
+    Returns:
+        The dependencies string with [File:] patterns converted to <include> tags.
+    """
+    # Pattern: <tag>[File: path]</tag> or <tag>\n[File: path]\n</tag>
+    pattern = r'(<[^>]+>)\s*\[File:\s*([^\]]+)\]\s*(</[^>]+>)'
+
+    def replacer(match: re.Match) -> str:
+        opening_tag = match.group(1)
+        path = match.group(2).strip()  # Strip whitespace from captured path
+        closing_tag = match.group(3)
+        return f'{opening_tag}<include>{path}</include>{closing_tag}'
+
+    fixed = re.sub(pattern, replacer, dependencies)
+    if fixed != dependencies:
+        console.print("[yellow]Warning: Fixed malformed [File:] patterns in dependencies[/yellow]")
+    return fixed
+
+
+def _extract_example_modules(content: str) -> Set[str]:
+    """Extract module names from _example.py includes.
+
+    Args:
+        content: The string content to search for include tags.
+
+    Returns:
+        A set of module names extracted from _example.py paths.
+        E.g., 'context/agentic_bug_example.py' -> 'agentic_bug'
+    """
+    pattern = r'<include>(.*?)</include>'
+    matches = re.findall(pattern, content, re.DOTALL)
+    modules = set()
+    for match in matches:
+        path = match.strip()
+        # Match pattern: context/[subdirs/]module_name_example.py
+        example_match = re.search(r'context/(?:[^/]+/)*([^/]+)_example\.py$', path)
+        if example_match:
+            modules.add(example_match.group(1))
+    return modules
+
+
+def _detect_circular_dependencies(
+    current_prompt: str,
+    new_dependencies: str,
+    prompts_dir: Optional[str] = None
+) -> List[List[str]]:
+    """Detect circular dependencies through example file includes.
+
+    Detects module-level circular dependencies where:
+    - Module A's prompt includes module B's example file
+    - Module B's prompt includes module A's example file
+
+    Args:
+        current_prompt: The current prompt file being processed.
+        new_dependencies: The new dependencies string to check.
+        prompts_dir: Optional base directory for resolving prompt paths.
+
+    Returns:
+        List of cycles found, where each cycle is a list of module names.
+    """
+    # Extract current module name from prompt filename
+    current_module = _extract_module_name(current_prompt)
+    if not current_module:
+        return []
+
+    # Extract module names from example includes in new dependencies
+    new_dep_modules = _extract_example_modules(new_dependencies)
+    if not new_dep_modules:
+        return []
+
+    cycles: List[List[str]] = []
+
+    # Determine base directory for prompts
+    if prompts_dir:
+        base_dir = Path(prompts_dir)
+    else:
+        # Try to find prompts directory relative to current prompt
+        current_path = Path(current_prompt)
+        if current_path.parent.name == 'prompts' or 'prompts' in str(current_path):
+            base_dir = current_path.parent
+        else:
+            base_dir = Path('prompts')
+
+    # Extract current prompt filename for cycle reporting
+    current_prompt_name = Path(current_prompt).name
+
+    # For each module we're about to depend on, check if it depends on us
+    for dep_module in new_dep_modules:
+        # Find the prompt file for this module (try common patterns)
+        prompt_patterns = [
+            f"{dep_module}_python.prompt",
+            f"{dep_module}_LLM.prompt",
+            f"{dep_module}.prompt",
+        ]
+
+        for pattern in prompt_patterns:
+            prompt_path = base_dir / pattern
+            if prompt_path.exists():
+                try:
+                    content = prompt_path.read_text(encoding='utf-8')
+                    # Check if this prompt includes our example file
+                    dep_modules = _extract_example_modules(content)
+                    if current_module in dep_modules:
+                        # Found circular dependency!
+                        # Use actual prompt filenames, not hardcoded suffixes
+                        cycles.append([
+                            current_prompt_name,
+                            pattern,
+                            current_prompt_name
+                        ])
+                except Exception:
+                    pass
+                break
+
+    return cycles
+
+
+def _filter_circular_dependencies(dependencies: str, cycles: List[List[str]]) -> str:
+    """Remove include tags that would create circular dependencies.
+
+    Args:
+        dependencies: The dependencies string containing include tags.
+        cycles: List of cycles, where each cycle is a list of prompt filenames.
+
+    Returns:
+        The dependencies string with circular dependency includes removed.
+    """
+    if not cycles:
+        return dependencies
+
+    # Extract module names from cycles (e.g., 'agentic_bug_python.prompt' -> 'agentic_bug')
+    problematic_modules: Set[str] = set()
+    for cycle in cycles:
+        for prompt_name in cycle:
+            # Extract module name from prompt filename using shared helper
+            module_name = _extract_module_name(prompt_name)
+            if module_name:
+                problematic_modules.add(module_name)
+
+    if not problematic_modules:
+        return dependencies
+
+    # Pattern to match include tags with _example.py files
+    # Matches: <wrapper><include>context/[subdirs/]module_example.py</include></wrapper>
+    # Using a simpler approach: find each include and check if it's problematic
+    result = dependencies
+    for module in problematic_modules:
+        # Remove includes for this module's example file
+        # Pattern: <wrapper><include>context/[subdirs/]module_example.py</include></wrapper>
+        pattern = rf'<[^>]+><include>context/(?:[^/]+/)*{re.escape(module)}_example\.py</include></[^>]+>\s*'
+        result = re.sub(pattern, '', result)
+
+    return result
+
+
 def auto_include(
     input_prompt: str,
     directory_path: str,
@@ -226,6 +391,23 @@ def auto_include(
         module_name = _extract_module_name(prompt_filename)
         dependencies = _filter_self_references(dependencies, module_name)
 
+        # Fix any malformed [File:] patterns from LLM output
+        dependencies = _fix_malformed_includes(dependencies)
+
+        # Detect and filter circular dependencies in prompt includes
+        if prompt_filename:
+            cycles = _detect_circular_dependencies(
+                current_prompt=prompt_filename,
+                new_dependencies=dependencies
+            )
+            if cycles:
+                dependencies = _filter_circular_dependencies(dependencies, cycles)
+                for cycle in cycles:
+                    console.print(
+                        f"[yellow]Warning: Filtered circular dependency: "
+                        f"{' -> '.join(cycle)}[/yellow]"
+                    )
+
         total_cost = summary_cost + llm_cost
         model_name = llm_model_name or summary_model