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

pdd/context_generator_main.py

@@ -1,193 +1,190 @@
-import sys
+from __future__ import annotations
 import ast
-from typing import Tuple, Optional
+import asyncio
+import json
+import os
+import sys
 from pathlib import Path
+from typing import Optional, Tuple, Dict, Any
 import click
-from rich import print as rprint
-
+import httpx
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
 from .construct_paths import construct_paths
 from .context_generator import context_generator
+from .core.cloud import CloudConfig
+# get_jwt_token imports removed - using CloudConfig.get_jwt_token() instead
+from .preprocess import preprocess
+from . import DEFAULT_STRENGTH, DEFAULT_TEMPERATURE
 
+console = Console()
+CLOUD_TIMEOUT_SECONDS = 400.0
 
-def _validate_python_syntax(code: str) -> Tuple[bool, Optional[str]]:
-    """
-    Validate that the code is valid Python syntax.
-
-    Returns:
-        Tuple of (is_valid, error_message)
-    """
+def _validate_and_fix_python_syntax(code: str, quiet: bool) -> str:
     try:
         ast.parse(code)
-        return True, None
-    except SyntaxError as e:
-        return False, f"SyntaxError at line {e.lineno}: {e.msg}"
-
-
-def _try_fix_json_garbage(code: str) -> Optional[str]:
-    """
-    Attempt to fix code that has JSON metadata garbage appended at the end.
-    This is a common LLM extraction failure pattern.
-
-    Returns:
-        Fixed code if successful, None if not fixable.
-    """
-    lines = code.split('\n')
-
-    # Look for JSON-like patterns at the end
-    json_patterns = ['"explanation":', '"focus":', '"description":', '"code":']
-
+        return code
+    except SyntaxError:
+        if not quiet:
+            console.print("[yellow]Warning: Generated code has syntax errors. Attempting to fix...[/yellow]")
+    lines = code.splitlines()
+    json_markers = ['"explanation":', '"focus":', '"description":', '"code":', '"filename":']
+    cut_index = -1
     for i in range(len(lines) - 1, -1, -1):
         line = lines[i].strip()
-
-        # If we find a line that's clearly JSON garbage
-        if any(pattern in line for pattern in json_patterns):
-            # Go back and find where valid Python ends
-            for j in range(i - 1, -1, -1):
-                candidate = '\n'.join(lines[:j + 1])
-                is_valid, _ = _validate_python_syntax(candidate)
-                if is_valid:
-                    return candidate
-            break
-
-        # If line is just "}" or "]", likely JSON ending
-        if line in ['}', ']', '},', '],']:
+        if any(marker in line for marker in json_markers) or line == "}" or line == "},":
+            cut_index = i
+    if cut_index != -1:
+        candidate = "\n".join(lines[:cut_index])
+        try:
+            ast.parse(candidate)
+            if not quiet:
+                console.print("[green]Fix successful: Removed trailing metadata.[/green]")
+            return candidate
+        except SyntaxError:
+            pass
+    low = 0
+    high = cut_index if cut_index != -1 else len(lines)
+    valid_len = 0
+    while low < high:
+        mid = (low + high + 1) // 2
+        candidate = "\n".join(lines[:mid])
+        try:
+            ast.parse(candidate)
+            valid_len = mid
+            low = mid
+        except SyntaxError:
+            high = mid - 1
+    for i in range(len(lines), max(0, len(lines) - 50), -1):
+        candidate = "\n".join(lines[:i])
+        try:
+            ast.parse(candidate)
+            if not quiet:
+                console.print("[green]Fix successful: Truncated invalid tail content.[/green]")
+            return candidate
+        except SyntaxError:
             continue
+    if not quiet:
+        console.print("[red]Fix failed: Could not automatically repair syntax.[/red]")
+    return code
 
-        # If line ends with '",  (JSON string end)
-        if line.endswith('",') or line.endswith('"'):
-            # Check if this looks like inside a JSON object
-            if any(pattern in lines[i] if i < len(lines) else '' for pattern in json_patterns):
-                continue
-
-    return None
-
-def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str, output: Optional[str]) -> Tuple[str, float, str]:
-    """
-    Main function to generate example code from a prompt file and an existing code file.
+async def _run_cloud_generation(prompt_content: str, code_content: str, language: str, strength: float, temperature: float, verbose: bool, pdd_env: str, token: str) -> Tuple[Optional[str], float, str]:
+    """Run cloud generation with the provided JWT token.
 
-    :param ctx: Click context containing command-line parameters.
-    :param prompt_file: Path to the prompt file that generated the code.
-    :param code_file: Path to the existing code file.
-    :param output: Optional path to save the generated example code.
-    :return: A tuple containing the generated example code, total cost, and model name used.
+    Note: JWT token must be obtained BEFORE calling this async function to avoid
+    nested asyncio.run() calls (CloudConfig.get_jwt_token() uses asyncio.run internally).
     """
     try:
-        # Construct file paths
-        input_file_paths = {
-            "prompt_file": prompt_file,
-            "code_file": code_file
-        }
-        command_options = {
-            "output": output
-        }
-        resolved_config, input_strings, output_file_paths, language = construct_paths(
-            input_file_paths=input_file_paths,
-            force=ctx.obj.get('force', False),
-            quiet=ctx.obj.get('quiet', False),
-            command="example",
-            command_options=command_options,
-            context_override=ctx.obj.get('context'),
-            confirm_callback=ctx.obj.get('confirm_callback')
-        )
-
-        # Load input files
-        prompt_content = input_strings["prompt_file"]
-        code_content = input_strings["code_file"]
-
-        # Get resolved output path for file path information
-        resolved_output = output_file_paths["output"]
-        
-        # Determine file path information for correct imports
-        from pathlib import Path
-        source_file_path = str(Path(code_file).resolve())
-        example_file_path = str(Path(resolved_output).resolve()) if resolved_output else ""
-        
-        # Extract module name from the code file
-        module_name = Path(code_file).stem
-
-        # Generate example code
-        strength = ctx.obj.get('strength', 0.5)
-        temperature = ctx.obj.get('temperature', 0)
-        time = ctx.obj.get('time')
-        example_code, total_cost, model_name = context_generator(
-            language=language,
-            code_module=code_content,
-            prompt=prompt_content,
-            strength=strength,
-            temperature=temperature,
-            time=time,
-            verbose=ctx.obj.get('verbose', False),
-            source_file_path=source_file_path,
-            example_file_path=example_file_path,
-            module_name=module_name
-        )
+        processed_prompt = preprocess(prompt_content, recursive=True, double_curly_brackets=False)
+    except Exception as e:
+        return None, 0.0, f"Preprocessing failed: {e}"
+    if verbose:
+        console.print(Panel(Text(processed_prompt[:500] + "..." if len(processed_prompt) > 500 else processed_prompt, overflow="fold"), title="[cyan]Preprocessed Prompt for Cloud[/cyan]", expand=False))
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+    payload = {"promptContent": processed_prompt, "codeContent": code_content, "language": language, "strength": strength, "temperature": temperature, "verbose": verbose}
+    async with httpx.AsyncClient(timeout=CLOUD_TIMEOUT_SECONDS) as client:
+        try:
+            cloud_url = CloudConfig.get_endpoint_url("generateExample")
+            response = await client.post(cloud_url, json=payload, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            generated_code = data.get("generatedExample", "")
+            total_cost = float(data.get("totalCost", 0.0))
+            model_name = data.get("modelName", "cloud-model")
+            if not generated_code:
+                return None, 0.0, "Cloud function returned empty code."
+            return generated_code, total_cost, model_name
+        except Exception as e:
+            return None, 0.0, f"Cloud error: {e}"
 
-        # Save results - if output is a directory, use resolved file path from construct_paths
-        if output is None:
-            final_output_path = resolved_output
+def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str, output: Optional[str]) -> Tuple[str, float, str]:
+    try:
+        input_file_paths = {"prompt_file": prompt_file, "code_file": code_file}
+        command_options = {"output": output}
+        resolved_config, input_strings, output_file_paths, language = construct_paths(input_file_paths=input_file_paths, force=ctx.obj.get('force', False), quiet=ctx.obj.get('quiet', False), command="example", command_options=command_options, context_override=ctx.obj.get('context'), confirm_callback=ctx.obj.get('confirm_callback'))
+        prompt_content = input_strings.get("prompt_file", "")
+        code_content = input_strings.get("code_file", "")
+        if output and not output.endswith("/") and not Path(output).is_dir():
+            resolved_output = output
         else:
-            try:
-                is_dir_hint = output.endswith('/')
-            except Exception:
-                is_dir_hint = False
-            if is_dir_hint or (Path(output).exists() and Path(output).is_dir()):
-                final_output_path = resolved_output
+            resolved_output = output_file_paths.get("output")
+        is_local = ctx.obj.get("local", False)
+        strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
+        temperature = ctx.obj.get('temperature', DEFAULT_TEMPERATURE)
+        verbose = ctx.obj.get('verbose', False)
+        quiet = ctx.obj.get('quiet', False)
+        pdd_env = os.environ.get("PDD_ENV", "local")
+        generated_code = None
+        total_cost = 0.0
+        model_name = ""
+        if not is_local:
+            if verbose:
+                console.print("Attempting cloud example generation...")
+
+            # Get JWT token BEFORE entering async context to avoid nested asyncio.run() calls
+            # (CloudConfig.get_jwt_token() uses asyncio.run internally for device flow auth)
+            jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
+            if not jwt_token:
+                if not quiet:
+                    console.print("[yellow]Cloud authentication failed. Falling back to local.[/yellow]")
+                is_local = True
             else:
-                final_output_path = output
-        if final_output_path and example_code is not None:
-            # Validate Python syntax before saving
-            if language == "python":
-                is_valid, error_msg = _validate_python_syntax(example_code)
-                if not is_valid:
-                    if not ctx.obj.get('quiet', False):
-                        rprint(f"[yellow]Warning: Generated code has syntax error: {error_msg}[/yellow]")
-                        rprint("[yellow]Attempting to fix JSON garbage pattern...[/yellow]")
-
-                    # Try to fix JSON garbage at end of file
-                    fixed_code = _try_fix_json_garbage(example_code)
-                    if fixed_code:
-                        is_valid_fixed, _ = _validate_python_syntax(fixed_code)
-                        if is_valid_fixed:
-                            if not ctx.obj.get('quiet', False):
-                                rprint("[green]Successfully removed garbage and fixed syntax.[/green]")
-                            example_code = fixed_code
-                        else:
-                            rprint("[red]Could not fix syntax error. Saving as-is.[/red]")
+                try:
+                    generated_code, total_cost, model_name = asyncio.run(_run_cloud_generation(prompt_content, code_content, language, strength, temperature, verbose, pdd_env, jwt_token))
+                    if generated_code:
+                        if verbose:
+                            console.print(Panel(f"Cloud generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Cloud Success[/green]", expand=False))
+                except httpx.TimeoutException:
+                    if not quiet:
+                        console.print(f"[yellow]Cloud execution timed out ({CLOUD_TIMEOUT_SECONDS}s). Falling back to local.[/yellow]")
+                    generated_code = None
+                except httpx.HTTPStatusError as e:
+                    status_code = e.response.status_code
+                    response_text = e.response.text or ""
+                    err_content = response_text[:200] if response_text else "No response content"
+                    if status_code == 402:
+                        console.print(f"[red]Insufficient credits: {err_content}[/red]")
+                        raise click.UsageError("Insufficient credits for cloud example generation")
+                    elif status_code == 401:
+                        console.print(f"[red]Authentication failed: {err_content}[/red]")
+                        raise click.UsageError("Cloud authentication failed")
+                    elif status_code == 403:
+                        console.print(f"[red]Access denied: {err_content}[/red]")
+                        raise click.UsageError("Access denied - user not approved")
                     else:
-                        rprint("[red]Could not detect fixable pattern. Saving as-is.[/red]")
-
-            with open(final_output_path, 'w') as f:
-                f.write(example_code)
-        elif final_output_path and example_code is None:
-            # Raise error instead of just warning
+                        if not quiet:
+                            console.print(f"[yellow]Cloud HTTP error ({status_code}): {err_content}. Falling back to local.[/yellow]")
+                        generated_code = None
+                except Exception as e:
+                    if verbose:
+                        console.print(f"[yellow]Cloud error: {e}. Falling back to local.[/yellow]")
+                    generated_code = None
+
+                if generated_code is None:
+                    if not quiet:
+                        console.print("[yellow]Cloud execution failed. Falling back to local.[/yellow]")
+                    is_local = True
+        if is_local:
+            # Compute file path info if not already computed (when --local flag is used from start)
+            source_file_path = str(Path(code_file).resolve())
+            example_file_path = str(Path(resolved_output).resolve()) if resolved_output else ""
+            module_name = Path(code_file).stem
+            generated_code, total_cost, model_name = context_generator(code_module=code_content, prompt=prompt_content, language=language, strength=strength, temperature=temperature, verbose=not quiet, source_file_path=source_file_path, example_file_path=example_file_path, module_name=module_name, time=ctx.obj.get('time'))
+        if not generated_code:
             raise click.UsageError("Example generation failed, no code produced.")
-
-        # Provide user feedback
-        if not ctx.obj.get('quiet', False):
-            if example_code is not None:
-                rprint("[bold green]Example code generated successfully.[/bold green]")
-                rprint(f"[bold]Model used:[/bold] {model_name}")
-                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
-                if final_output_path and example_code is not None:
-                    rprint(f"[bold]Example code saved to:[/bold] {final_output_path}")
-            else:
-                rprint("[bold red]Example code generation failed.[/bold red]")
-                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
-
-        # Always print example code, even in quiet mode (if it exists)
-        if example_code is not None:
-            rprint("[bold]Generated Example Code:[/bold]")
-            rprint(example_code)
-        else:
-            rprint("[bold red]No example code generated due to errors.[/bold red]")
-
-        return example_code, total_cost, model_name
-
-    except click.Abort:
-        # User cancelled - re-raise to stop the sync loop
-        raise
+        if language and language.lower() == "python":
+            generated_code = _validate_and_fix_python_syntax(generated_code, quiet)
+        if resolved_output:
+            out_path = Path(resolved_output)
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+            out_path.write_text(generated_code, encoding="utf-8")
+        if not quiet:
+            console.print("[bold green]Example generation completed successfully.[/bold green]")
+            console.print(f"[bold]Model used:[/bold] {model_name}")
+            console.print(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+        return generated_code, total_cost, model_name
     except Exception as e:
         if not ctx.obj.get('quiet', False):
-            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: {e}"
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        raise e

pdd/continue_generation.py

@@ -84,7 +84,8 @@ def continue_generation(
             temperature=0,
             time=time,
             output_pydantic=TrimResultsStartOutput,
-            verbose=verbose
+            verbose=verbose,
+            language=language,
         )
         total_cost += trim_start_response['cost']
         code_block = trim_start_response['result'].code_block
@@ -111,7 +112,8 @@ def continue_generation(
                 strength=strength,
                 temperature=temperature,
                 time=time,
-                verbose=verbose
+                verbose=verbose,
+                language=language,
             )
             
             total_cost += continue_response['cost']
@@ -171,7 +173,8 @@ def continue_generation(
                     temperature=0,
                     time=time,
                     output_pydantic=TrimResultsOutput,
-                    verbose=verbose
+                    verbose=verbose,
+                    language=language,
                 )
                 total_cost += trim_response['cost']
                 code_block += trim_response['result'].trimmed_continued_generation

pdd/core/__init__.py

@@ -0,0 +1,33 @@
+"""
+Core utilities and configuration for PDD CLI.
+"""
+
+from .cloud import (
+    CloudConfig,
+    AuthError,
+    NetworkError,
+    TokenError,
+    UserCancelledError,
+    RateLimitError,
+    FIREBASE_API_KEY_ENV,
+    GITHUB_CLIENT_ID_ENV,
+    PDD_CLOUD_URL_ENV,
+    PDD_JWT_TOKEN_ENV,
+    DEFAULT_BASE_URL,
+    CLOUD_ENDPOINTS,
+)
+
+__all__ = [
+    'CloudConfig',
+    'AuthError',
+    'NetworkError',
+    'TokenError',
+    'UserCancelledError',
+    'RateLimitError',
+    'FIREBASE_API_KEY_ENV',
+    'GITHUB_CLIENT_ID_ENV',
+    'PDD_CLOUD_URL_ENV',
+    'PDD_JWT_TOKEN_ENV',
+    'DEFAULT_BASE_URL',
+    'CLOUD_ENDPOINTS',
+]

pdd/core/cli.py

@@ -194,7 +194,7 @@ class PDDCLI(click.Group):
     "--force",
     is_flag=True,
     default=False,
-    help="Overwrite existing files without asking for confirmation (commonly used with 'sync' to update generated outputs).",
+    help="Skip all interactive prompts (file overwrites, API key requests). Useful for CI/automation.",
 )
 @click.option(
     "--strength",
@@ -262,11 +262,17 @@ class PDDCLI(click.Group):
     help="List available contexts from .pddrc and exit.",
 )
 @click.option(
-    "--core-dump",
+    "--core-dump/--no-core-dump",
     "core_dump",
-    is_flag=True,
-    default=False,
-    help="Write a JSON core dump for this run into .pdd/core_dumps (for bug reports).",
+    default=True,
+    help="Write a JSON core dump for this run into .pdd/core_dumps (default: on). Use --no-core-dump to disable.",
+)
+@click.option(
+    "--keep-core-dumps",
+    "keep_core_dumps",
+    type=click.IntRange(min=0),
+    default=10,
+    help="Number of core dumps to keep (default: 10, min: 0). Older dumps are garbage collected after each dump write.",
 )
 @click.version_option(version=__version__, package_name="pdd-cli")
 @click.pass_context
@@ -284,6 +290,7 @@ def cli(
     context_override: Optional[str],
     list_contexts: bool,
     core_dump: bool,
+    keep_core_dumps: int,
 ):
     """
     Main entry point for the PDD CLI. Handles global options and initializes context.
@@ -296,6 +303,8 @@ def cli(
 
     ctx.ensure_object(dict)
     ctx.obj["force"] = force
+    if force:
+        os.environ['PDD_FORCE'] = '1'
     # Only set strength/temperature if explicitly provided (not None)
     # This allows .get("key", default) to return the default when CLI didn't pass a value
     if strength is not None:
@@ -307,11 +316,20 @@ def cli(
     ctx.obj["output_cost"] = output_cost
     ctx.obj["review_examples"] = review_examples
     ctx.obj["local"] = local
+    # Propagate --local flag to environment for llm_invoke cloud detection
+    if local:
+        os.environ['PDD_FORCE_LOCAL'] = '1'
     # Use DEFAULT_TIME if time is not provided
     ctx.obj["time"] = time if time is not None else DEFAULT_TIME
     # Persist context override for downstream calls
     ctx.obj["context"] = context_override
     ctx.obj["core_dump"] = core_dump
+    ctx.obj["keep_core_dumps"] = keep_core_dumps
+
+    # Garbage collect old core dumps on every CLI invocation (Issue #231)
+    # This runs regardless of --no-core-dump to ensure cleanup always happens
+    from .dump import garbage_collect_core_dumps
+    garbage_collect_core_dumps(keep=keep_core_dumps)
 
     # Set up terminal output capture if core_dump is enabled
     if core_dump:
@@ -441,7 +459,7 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
                     console.print(f"  [error]Step {i+1} ({command_name}):[/error] Command failed.")
         # Check if the result is the expected tuple structure from @track_cost or preprocess success
         elif isinstance(result_tuple, tuple) and len(result_tuple) == 3:
-            _result_data, cost, model_name = result_tuple
+            result_data, cost, model_name = result_tuple
             total_cost += cost
             if not ctx.obj.get("quiet"):
                 # Special handling for preprocess success message (check actual command name)
@@ -451,6 +469,25 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
                 else:
                     # Generic output using potentially "Unknown Command" name
                     console.print(f"  [info]Step {i+1} ({command_name}):[/info] Cost: ${cost:.6f}, Model: {model_name}")
+                
+                # Display examples used for grounding
+                if isinstance(result_data, dict) and result_data.get("examplesUsed"):
+                    console.print("    Examples used:")
+                    for ex in result_data["examplesUsed"]:
+                        slug = ex.get("slug", "unknown")
+                        title = ex.get("title", "Untitled")
+                        console.print(f"      - {slug} (\"{title}\")")
+
+        # Handle dicts with examplesUsed (e.g. from commands not using track_cost but returning metadata)
+        elif isinstance(result_tuple, dict) and result_tuple.get("examplesUsed"):
+            if not ctx.obj.get("quiet"):
+                console.print(f"  [info]Step {i+1} ({command_name}):[/info] Command completed.")
+                console.print("    Examples used:")
+                for ex in result_tuple["examplesUsed"]:
+                    slug = ex.get("slug", "unknown")
+                    title = ex.get("title", "Untitled")
+                    console.print(f"      - {slug} (\"{title}\")")
+
         else:
             # Handle unexpected return types if necessary
             if not ctx.obj.get("quiet"):
@@ -463,7 +500,7 @@ def process_commands(ctx: click.Context, results: List[Optional[Tuple[Any, float
         if any(res is not None and isinstance(res, tuple) and len(res) == 3 for res in normalized_results):
             console.print(f"[info]Total Estimated Cost:[/info] ${total_cost:.6f}")
         # Indicate if the chain might have been incomplete due to errors
-        if num_results < num_commands and not all(res is None for res in results): # Avoid printing if all failed
+        if num_results < num_commands and results is not None and not all(res is None for res in results): # Avoid printing if all failed
             console.print("[warning]Note: Chain may have terminated early due to errors.[/warning]")
         console.print("[info]-------------------------------------[/info]")