PyPI - pdd-cli - Versions diffs - 0.0.118__py3-none-any.whl → 0.0.121__py3-none-any.whl - Mend

pdd-cli 0.0.118py3-none-any.whl → 0.0.121py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

pdd/__init__.py +1 -1
pdd/agentic_bug_orchestrator.py +15 -6
pdd/agentic_change_orchestrator.py +18 -7
pdd/agentic_common.py +68 -40
pdd/agentic_crash.py +2 -1
pdd/agentic_e2e_fix_orchestrator.py +165 -9
pdd/agentic_update.py +2 -1
pdd/agentic_verify.py +3 -2
pdd/auto_include.py +51 -0
pdd/commands/analysis.py +32 -25
pdd/commands/connect.py +69 -1
pdd/commands/fix.py +31 -13
pdd/commands/generate.py +5 -0
pdd/commands/modify.py +47 -11
pdd/commands/utility.py +12 -7
pdd/core/cli.py +17 -4
pdd/core/dump.py +68 -20
pdd/fix_main.py +4 -2
pdd/frontend/dist/assets/index-CUWd8al1.js +450 -0
pdd/frontend/dist/index.html +1 -1
pdd/llm_invoke.py +82 -12
pdd/operation_log.py +342 -0
pdd/postprocess.py +122 -100
pdd/prompts/agentic_change_step12_create_pr_LLM.prompt +11 -2
pdd/prompts/generate_test_LLM.prompt +0 -1
pdd/prompts/generate_test_from_example_LLM.prompt +251 -0
pdd/prompts/prompt_code_diff_LLM.prompt +29 -25
pdd/server/routes/prompts.py +26 -1
pdd/server/terminal_spawner.py +15 -7
pdd/sync_orchestration.py +164 -147
pdd/sync_order.py +304 -0
pdd/update_main.py +48 -24
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/METADATA +3 -3
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/RECORD +37 -35
pdd/frontend/dist/assets/index-DQ3wkeQ2.js +0 -449
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/WHEEL +0 -0
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/entry_points.txt +0 -0
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/licenses/LICENSE +0 -0
{pdd_cli-0.0.118.dist-info → pdd_cli-0.0.121.dist-info}/top_level.txt +0 -0

pdd/frontend/dist/index.html CHANGED Viewed

@@ -367,7 +367,7 @@
   }
 }
 </script>
-  <script type="module" crossorigin src="/assets/index-DQ3wkeQ2.js"></script>
+  <script type="module" crossorigin src="/assets/index-CUWd8al1.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-B5DZHykP.css">
 </head>
   <body class="bg-surface-950 text-gray-200">

pdd/llm_invoke.py CHANGED Viewed

@@ -146,20 +146,88 @@ class InsufficientCreditsError(Exception):
 # --- Cloud Execution Helpers ---
 def _ensure_all_properties_required(schema: Dict[str, Any]) -> Dict[str, Any]:
-    """Ensure ALL properties are in the required array (OpenAI strict mode requirement).
+    """Recursively ensure ALL properties are in the required array (OpenAI strict mode).
-    OpenAI's strict mode requires that all properties in a JSON schema are listed
-    in the 'required' array. Pydantic's model_json_schema() only includes fields
-    without default values in 'required', which causes OpenAI to reject the schema.
+    OpenAI's strict mode requires that all properties at ALL levels of a JSON schema
+    are listed in the 'required' array. Pydantic's model_json_schema() only includes
+    fields without default values in 'required', which causes OpenAI to reject the schema.
+    This function walks the entire schema tree and ensures every object type has all
+    its properties in the 'required' array.
     Args:
         schema: A JSON schema dictionary
     Returns:
-        The schema with all properties added to 'required'
+        The schema with all properties added to 'required' at all nesting levels
     """
-    if 'properties' in schema:
+    if not isinstance(schema, dict):
+        return schema
+    # If this is an object with properties, make all properties required
+    if schema.get('type') == 'object' and 'properties' in schema:
         schema['required'] = list(schema['properties'].keys())
+        # Recurse into each property
+        for prop_schema in schema['properties'].values():
+            _ensure_all_properties_required(prop_schema)
+    # Handle array items
+    if schema.get('type') == 'array' and 'items' in schema:
+        _ensure_all_properties_required(schema['items'])
+    # Handle anyOf/oneOf/allOf
+    for key in ('anyOf', 'oneOf', 'allOf'):
+        if key in schema:
+            for sub_schema in schema[key]:
+                _ensure_all_properties_required(sub_schema)
+    # Handle $defs
+    if '$defs' in schema:
+        for def_schema in schema['$defs'].values():
+            _ensure_all_properties_required(def_schema)
+    return schema
+def _add_additional_properties_false(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively add additionalProperties: false to all object schemas.
+    OpenAI's strict mode requires additionalProperties: false on ALL object
+    schemas, including nested ones. This function walks the schema tree and
+    adds the property to every object type.
+    Args:
+        schema: A JSON schema dictionary
+    Returns:
+        The schema with additionalProperties: false on all objects
+    """
+    if not isinstance(schema, dict):
+        return schema
+    # If this is an object type, add additionalProperties: false
+    if schema.get('type') == 'object':
+        schema['additionalProperties'] = False
+        # Recursively process properties
+        if 'properties' in schema:
+            for prop_name, prop_schema in schema['properties'].items():
+                _add_additional_properties_false(prop_schema)
+    # Handle arrays - process items schema
+    if schema.get('type') == 'array' and 'items' in schema:
+        _add_additional_properties_false(schema['items'])
+    # Handle anyOf, oneOf, allOf
+    for key in ('anyOf', 'oneOf', 'allOf'):
+        if key in schema:
+            for sub_schema in schema[key]:
+                _add_additional_properties_false(sub_schema)
+    # Handle $defs (Pydantic's reference definitions)
+    if '$defs' in schema:
+        for def_name, def_schema in schema['$defs'].items():
+            _add_additional_properties_false(def_schema)
     return schema
@@ -1919,8 +1987,8 @@ def llm_invoke(
                         schema = output_pydantic.model_json_schema()
                         # Ensure all properties are in required array (OpenAI strict mode requirement)
                         _ensure_all_properties_required(schema)
-                        # Add additionalProperties: false for strict mode (required by OpenAI)
-                        schema["additionalProperties"] = False
+                        # Add additionalProperties: false recursively for strict mode (required by OpenAI)
+                        _add_additional_properties_false(schema)
                         response_format = {
                             "type": "json_schema",
                             "json_schema": {
@@ -1945,8 +2013,10 @@ def llm_invoke(
                                 "strict": False
                             }
                         }
-                        # Add additionalProperties: false for strict mode (required by OpenAI)
-                        response_format["json_schema"]["schema"]["additionalProperties"] = False
+                        # Ensure all properties are in required array (OpenAI strict mode requirement)
+                        _ensure_all_properties_required(response_format["json_schema"]["schema"])
+                        # Add additionalProperties: false recursively for strict mode (required by OpenAI)
+                        _add_additional_properties_false(response_format["json_schema"]["schema"])
                     litellm_kwargs["response_format"] = response_format
@@ -2133,8 +2203,8 @@ def llm_invoke(
                                 # Ensure all properties are in required array (OpenAI strict mode requirement)
                                 _ensure_all_properties_required(schema)
-                                # Add additionalProperties: false for strict mode (required by OpenAI)
-                                schema['additionalProperties'] = False
+                                # Add additionalProperties: false recursively for strict mode (required by OpenAI)
+                                _add_additional_properties_false(schema)
                                 # Use text.format with json_schema for structured output
                                 text_block = {

pdd/operation_log.py ADDED Viewed

@@ -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-cli 0.0.118__py3-none-any.whl → 0.0.121__py3-none-any.whl

pdd-cli 0.0.118py3-none-any.whl → 0.0.121py3-none-any.whl