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

pdd/load_prompt_template.py

@@ -1,8 +1,7 @@
 from pathlib import Path
-import os
 from typing import Optional
-import sys
 from rich import print
+from pdd.path_resolution import get_default_resolver
 
 def print_formatted(message: str) -> None:
     """Print message with raw formatting tags for testing compatibility."""
@@ -23,40 +22,22 @@ def load_prompt_template(prompt_name: str) -> Optional[str]:
         print_formatted("[red]Unexpected error loading prompt template[/red]")
         return None
 
-    # Step 1: Get project path from environment variable (preferred),
-    # else fall back to auto-detect based on this module's location or CWD.
-    project_path_env = os.getenv('PDD_PATH')
-    candidate_paths = []
-    if project_path_env:
-        candidate_paths.append(Path(project_path_env))
+    resolver = get_default_resolver()
+    prompt_path = resolver.resolve_prompt_template(prompt_name)
 
-    # Fallback 1: repository root inferred from this module (pdd/ => repo root)
-    try:
-        module_root = Path(__file__).resolve().parent  # pdd/
-        repo_root = module_root.parent                 # repo root
-        candidate_paths.append(repo_root)
-    except Exception:
-        pass
-
-    # Fallback 2: current working directory
-    candidate_paths.append(Path.cwd())
-
-    # Build candidate prompt paths to try in order
-    prompt_candidates = []
-    for cp in candidate_paths:
-        # Check both <path>/prompts/ and <path>/pdd/prompts/
-        # The latter handles installed package case where prompts are in pdd/prompts/
-        prompt_candidates.append(cp / 'prompts' / f"{prompt_name}.prompt")
-        prompt_candidates.append(cp / 'pdd' / 'prompts' / f"{prompt_name}.prompt")
+    if prompt_path is None:
+        candidate_roots = []
+        if resolver.pdd_path_env is not None:
+            candidate_roots.append(resolver.pdd_path_env)
+        if resolver.repo_root is not None:
+            candidate_roots.append(resolver.repo_root)
+        candidate_roots.append(resolver.cwd)
 
-    # Step 2: Load and return the prompt template
-    prompt_path: Optional[Path] = None
-    for candidate in prompt_candidates:
-        if candidate.exists():
-            prompt_path = candidate
-            break
+        prompt_candidates = []
+        for root in candidate_roots:
+            prompt_candidates.append(root / 'prompts' / f"{prompt_name}.prompt")
+            prompt_candidates.append(root / 'pdd' / 'prompts' / f"{prompt_name}.prompt")
 
-    if prompt_path is None:
         tried = "\n".join(str(c) for c in prompt_candidates)
         print_formatted(
             f"[red]Prompt file not found in any candidate locations for '{prompt_name}'. Tried:\n{tried}[/red]"
@@ -82,4 +63,4 @@ if __name__ == "__main__":
     prompt = load_prompt_template("example_prompt")
     if prompt:
         print_formatted("[blue]Loaded prompt template:[/blue]")
-        print_formatted(prompt)
+        print_formatted(prompt)

pdd/operation_log.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import functools
+import json
+import os
+import re
+
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from rich.console import Console
+
+# We assume standard paths relative to the project root
+PDD_DIR = ".pdd"
+META_DIR = os.path.join(PDD_DIR, "meta")
+
+
+def ensure_meta_dir() -> None: 
+    """Ensure the .pdd/meta directory exists."""
+    os.makedirs(META_DIR, exist_ok=True)
+
+
+def get_log_path(basename: str, language: str) -> Path:
+    """Get the path to the sync log for a specific module."""
+    ensure_meta_dir()
+    return Path(META_DIR) / f"{basename}_{language}_sync.log"
+
+
+def get_fingerprint_path(basename: str, language: str) -> Path:
+    """Get the path to the fingerprint JSON file for a specific module."""
+    ensure_meta_dir()
+    return Path(META_DIR) / f"{basename}_{language}.json"
+
+
+def get_run_report_path(basename: str, language: str) -> Path:
+    """Get the path to the run report file for a specific module."""
+    ensure_meta_dir()
+    return Path(META_DIR) / f"{basename}_{language}_run.json"
+
+
+def infer_module_identity(prompt_file_path: Union[str, Path]) -> Tuple[Optional[str], Optional[str]]:
+    """
+    Infer basename and language from a prompt file path.
+    
+    Expected pattern: prompts/{basename}_{language}.prompt
+    
+    Args:
+        prompt_file_path: Path to the prompt file.
+        
+    Returns:
+        Tuple of (basename, language) or (None, None) if inference fails.
+    """
+    path_obj = Path(prompt_file_path)
+    filename = path_obj.stem  # e.g., "my_module_python" from "my_module_python.prompt"
+    
+    # Try to split by the last underscore to separate language
+    # This is a heuristic; strict naming conventions are assumed
+    match = re.match(r"^(.*)_([^_]+)$", filename)
+    if match:
+        basename = match.group(1)
+        language = match.group(2)
+        return basename, language
+        
+    return None, None
+
+
+def load_operation_log(basename: str, language: str) -> List[Dict[str, Any]]:
+    """
+    Load all log entries for a module.
+    
+    Args:
+        basename: Module basename.
+        language: Module language.
+        
+    Returns:
+        List of log entries (dictionaries).
+    """
+    log_path = get_log_path(basename, language)
+    entries = []
+    
+    if log_path.exists():
+        try:
+            with open(log_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    if line.strip():
+                        try:
+                            entry = json.loads(line)
+                            # Backwards compatibility: defaulting invocation_mode to "sync"
+                            if "invocation_mode" not in entry:
+                                entry["invocation_mode"] = "sync"
+                            entries.append(entry)
+                        except json.JSONDecodeError:
+                            continue
+        except Exception:
+            # If log is corrupt or unreadable, return empty list rather than crashing
+            pass
+            
+    return entries
+
+
+def append_log_entry(
+    basename: str, 
+    language: str, 
+    entry: Dict[str, Any]
+) -> None:
+    """
+    Append a single entry to the module's sync log.
+    
+    Args:
+        basename: Module basename.
+        language: Module language.
+        entry: Dictionary of data to log.
+    """
+    log_path = get_log_path(basename, language)
+    
+    # Ensure standard fields exist
+    if "timestamp" not in entry:
+        entry["timestamp"] = datetime.now().isoformat()
+    
+    try:
+        with open(log_path, 'a', encoding='utf-8') as f:
+            f.write(json.dumps(entry) + "\n")
+    except Exception as e:
+        # Fallback console warning if logging fails
+        console = Console()
+        console.print(f"[yellow]Warning: Failed to write to log file {log_path}: {e}[/yellow]")
+
+
+def create_log_entry(
+    operation: str,
+    reason: str,
+    invocation_mode: str = "sync",
+    estimated_cost: float = 0.0,
+    confidence: float = 0.0,
+    decision_type: str = "unknown"
+) -> Dict[str, Any]:
+    """
+    Create a new log entry dictionary structure.
+    """
+    return {
+        "timestamp": datetime.now().isoformat(),
+        "operation": operation,
+        "reason": reason,
+        "invocation_mode": invocation_mode,
+        "estimated_cost": estimated_cost,
+        "confidence": confidence,
+        "decision_type": decision_type,
+        "success": False,
+        "duration": 0.0,
+        "actual_cost": 0.0,
+        "model": "unknown",
+        "error": None
+    }
+
+
+def create_manual_log_entry(operation: str) -> Dict[str, Any]:
+    """
+    Convenience function to create a manual invocation log entry dict.
+    """
+    return create_log_entry(
+        operation=operation,
+        reason="Manual invocation via CLI",
+        invocation_mode="manual"
+    )
+
+
+def update_log_entry(
+    entry: Dict[str, Any],
+    success: bool,
+    cost: float,
+    model: str,
+    duration: float,
+    error: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Update a log entry with execution results.
+    """
+    entry["success"] = success
+    entry["actual_cost"] = cost
+    entry["model"] = model
+    entry["duration"] = duration
+    entry["error"] = error
+    return entry
+
+
+def log_event(
+    basename: str,
+    language: str,
+    event_type: str,
+    details: Any,
+    invocation_mode: str = "manual"
+) -> None:
+    """
+    Log a special event to the sync log.
+    """
+    entry = {
+        "timestamp": datetime.now().isoformat(),
+        "type": "event",
+        "event_type": event_type,
+        "details": details,
+        "invocation_mode": invocation_mode
+    }
+    append_log_entry(basename, language, entry)
+
+
+def save_fingerprint(
+    basename: str,
+    language: str,
+    operation: str,
+    paths: Optional[Dict[str, Path]] = None,
+    cost: float = 0.0,
+    model: str = "unknown"
+) -> None:
+    """
+    Save the current fingerprint/state to the state file.
+
+    Writes the full Fingerprint dataclass format compatible with read_fingerprint()
+    in sync_determine_operation.py. This ensures manual commands (generate, example)
+    don't break sync's fingerprint tracking.
+    """
+    from dataclasses import asdict
+    from datetime import timezone
+    from .sync_determine_operation import calculate_current_hashes, Fingerprint
+    from . import __version__
+
+    path = get_fingerprint_path(basename, language)
+
+    # Calculate file hashes from paths (if provided)
+    current_hashes = calculate_current_hashes(paths) if paths else {}
+
+    # Create Fingerprint with same format as _save_fingerprint_atomic
+    fingerprint = Fingerprint(
+        pdd_version=__version__,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        command=operation,
+        prompt_hash=current_hashes.get('prompt_hash'),
+        code_hash=current_hashes.get('code_hash'),
+        example_hash=current_hashes.get('example_hash'),
+        test_hash=current_hashes.get('test_hash'),
+        test_files=current_hashes.get('test_files'),
+    )
+
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(asdict(fingerprint), f, indent=2)
+    except Exception as e:
+        console = Console()
+        console.print(f"[yellow]Warning: Failed to save fingerprint to {path}: {e}[/yellow]")
+
+
+def save_run_report(basename: str, language: str, report_data: Dict[str, Any]) -> None:
+    """
+    Save a run report (test results) to the state file.
+    """
+    path = get_run_report_path(basename, language)
+    try:
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(report_data, f, indent=2)
+    except Exception as e:
+        console = Console()
+        console.print(f"[yellow]Warning: Failed to save run report to {path}: {e}[/yellow]")
+
+
+def clear_run_report(basename: str, language: str) -> None:
+    """
+    Remove an existing run report if it exists.
+    """
+    path = get_run_report_path(basename, language)
+    if path.exists():
+        try:
+            os.remove(path)
+        except Exception:
+            pass
+
+
+def log_operation(
+    operation: str,
+    updates_fingerprint: bool = False,
+    updates_run_report: bool = False,
+    clears_run_report: bool = False
+) -> Callable:
+    """
+    Decorator for Click commands to automatically log operations and manage state.
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Try to get prompt_file from named kwarg first
+            prompt_file = kwargs.get('prompt_file')
+
+            # If not found, check if there's an 'args' tuple (for commands using nargs=-1)
+            # and the first element looks like a prompt file path
+            if not prompt_file:
+                cli_args = kwargs.get('args')
+                if cli_args and len(cli_args) > 0:
+                    first_arg = str(cli_args[0])
+                    # Check if it looks like a prompt file (ends with .prompt)
+                    if first_arg.endswith('.prompt'):
+                        prompt_file = first_arg
+
+            basename, language = (None, None)
+            if prompt_file:
+                basename, language = infer_module_identity(prompt_file)
+
+            if basename and language and clears_run_report:
+                clear_run_report(basename, language)
+
+            entry = create_manual_log_entry(operation=operation)
+            start_time = time.time()
+            success = False
+            result = None
+            error_msg = None
+            
+            try:
+                result = func(*args, **kwargs)
+                success = True
+                return result
+            except Exception as e:
+                success = False
+                error_msg = str(e)
+                raise
+            finally:
+                duration = time.time() - start_time
+                cost = 0.0
+                model = "unknown"
+                if success and result:
+                    if isinstance(result, tuple) and len(result) >= 3:
+                        if isinstance(result[1], (int, float)): cost = float(result[1])
+                        if isinstance(result[2], str): model = str(result[2])
+
+                update_log_entry(entry, success=success, cost=cost, model=model, duration=duration, error=error_msg)
+                if basename and language:
+                    append_log_entry(basename, language, entry)
+                    if success:
+                        if updates_fingerprint:
+                            save_fingerprint(basename, language, operation=operation, cost=cost, model=model)
+                        if updates_run_report and isinstance(result, dict):
+                            save_run_report(basename, language, result)
+        return wrapper
+    return decorator

pdd/path_resolution.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+from typing import Literal, Optional
+
+IncludeProfile = Literal["cwd_then_package_then_repo"]
+PromptProfile = Literal["pdd_path_then_repo_then_cwd"]
+DataProfile = Literal["pdd_path_only"]
+ProjectRootProfile = Literal["pdd_path_then_marker_then_cwd"]
+
+
+@dataclass(frozen=True)
+class PathResolver:
+    cwd: Path
+    pdd_path_env: Optional[Path]
+    package_root: Path
+    repo_root: Optional[Path]
+
+    def resolve_include(self, rel: str, profile: IncludeProfile = "cwd_then_package_then_repo") -> Path:
+        if profile != "cwd_then_package_then_repo":
+            raise ValueError(f"Unsupported include profile: {profile}")
+
+        cwd_path = self.cwd / rel
+        if cwd_path.exists():
+            return cwd_path
+
+        pkg_path = self.package_root / rel
+        if pkg_path.exists():
+            return pkg_path
+
+        if self.repo_root is not None:
+            repo_path = self.repo_root / rel
+            if repo_path.exists():
+                return repo_path
+
+        return cwd_path
+
+    def resolve_prompt_template(
+        self,
+        name: str,
+        profile: PromptProfile = "pdd_path_then_repo_then_cwd",
+    ) -> Optional[Path]:
+        if profile != "pdd_path_then_repo_then_cwd":
+            raise ValueError(f"Unsupported prompt profile: {profile}")
+
+        roots = []
+        if self.pdd_path_env is not None:
+            roots.append(self.pdd_path_env)
+        if self.repo_root is not None:
+            roots.append(self.repo_root)
+        roots.append(self.cwd)
+
+        prompt_file = f"{name}.prompt"
+        for root in roots:
+            candidate = root / "prompts" / prompt_file
+            if candidate.exists():
+                return candidate
+            candidate = root / "pdd" / "prompts" / prompt_file
+            if candidate.exists():
+                return candidate
+
+        return None
+
+    def resolve_data_file(self, rel: str, profile: DataProfile = "pdd_path_only") -> Path:
+        if profile != "pdd_path_only":
+            raise ValueError(f"Unsupported data profile: {profile}")
+        if self.pdd_path_env is None:
+            raise ValueError("PDD_PATH environment variable is not set.")
+        return self.pdd_path_env / rel
+
+    def resolve_project_root(
+        self,
+        profile: ProjectRootProfile = "pdd_path_then_marker_then_cwd",
+        max_levels: int = 5,
+    ) -> Path:
+        if profile != "pdd_path_then_marker_then_cwd":
+            raise ValueError(f"Unsupported project root profile: {profile}")
+
+        if (
+            self.pdd_path_env is not None
+            and self.pdd_path_env.is_dir()
+            and not _is_within(self.pdd_path_env, self.package_root)
+        ):
+            return self.pdd_path_env
+
+        current = self.cwd
+        for _ in range(max_levels):
+            if _has_project_marker(current):
+                return current
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+        return self.cwd
+
+
+def get_default_resolver() -> PathResolver:
+    cwd = Path.cwd().resolve()
+
+    pdd_path_env = None
+    env_value = os.getenv("PDD_PATH")
+    if env_value:
+        pdd_path_env = Path(env_value).expanduser().resolve()
+
+    package_root = Path(__file__).resolve().parent
+    repo_root = package_root.parent
+
+    return PathResolver(
+        cwd=cwd,
+        pdd_path_env=pdd_path_env,
+        package_root=package_root,
+        repo_root=repo_root,
+    )
+
+
+def _has_project_marker(path: Path) -> bool:
+    return (
+        (path / ".git").exists()
+        or (path / "pyproject.toml").exists()
+        or (path / "data").is_dir()
+        or (path / ".env").exists()
+    )
+
+
+def _is_within(path: Path, parent: Path) -> bool:
+    try:
+        resolved_path = path.resolve()
+        resolved_parent = parent.resolve()
+    except Exception:
+        return False
+
+    if resolved_path == resolved_parent:
+        return True
+    parent_str = str(resolved_parent)
+    if not parent_str.endswith(os.sep):
+        parent_str = parent_str + os.sep
+    return str(resolved_path).startswith(parent_str)