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

pdd/context_generator.py

@@ -16,6 +16,9 @@ def context_generator(
     temperature: float = 0,
     time: Optional[float] = DEFAULT_TIME,
     verbose: bool = False,
+    source_file_path: str = None,
+    example_file_path: str = None,
+    module_name: str = None,
 ) -> tuple:
     """
     Generates a concise example on how to use a given code module properly.
@@ -79,7 +82,10 @@ def context_generator(
             input_json={
                 "code_module": code_module,
                 "processed_prompt": processed_prompt,
-                "language": language
+                "language": language,
+                "source_file_path": source_file_path or "",
+                "example_file_path": example_file_path or "",
+                "module_name": module_name or ""
             },
             strength=strength,
             temperature=temperature,
@@ -95,6 +101,7 @@ def context_generator(
                 strength=0.5,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
         except Exception as e:
@@ -112,6 +119,7 @@ def context_generator(
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost = llm_response['cost'] + unfinished_cost + continue_cost
@@ -149,4 +157,4 @@ if __name__ == "__main__":
         print("[bold green]Generated Example Code:[/bold green]")
         print(example_code)
         print(f"[bold blue]Total Cost: ${total_cost:.6f}[/bold blue]")
-        print(f"[bold blue]Model Name: {model_name}[/bold blue]")
+        print(f"[bold blue]Model Name: {model_name}[/bold blue]")

pdd/context_generator_main.py

@@ -1,91 +1,190 @@
+from __future__ import annotations
+import ast
+import asyncio
+import json
+import os
 import sys
-from typing import Tuple, Optional
+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
 
-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.
+console = Console()
+CLOUD_TIMEOUT_SECONDS = 400.0
 
-    :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.
-    """
+def _validate_and_fix_python_syntax(code: str, quiet: bool) -> str:
     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
-        )
+        ast.parse(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 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
 
-        # Load input files
-        prompt_content = input_strings["prompt_file"]
-        code_content = input_strings["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.
 
-        # 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)
-        )
-
-        # Save results - prioritize orchestration output path over construct_paths result
-        final_output_path = output or output_file_paths["output"]
-        print(f"DEBUG: output param = {output}")
-        print(f"DEBUG: output_file_paths['output'] = {output_file_paths['output']}")
-        print(f"DEBUG: final_output_path = {final_output_path}")
-        if final_output_path and example_code is not None:
-            with open(final_output_path, 'w') as f:
-                f.write(example_code)
-        elif final_output_path and example_code is None:
-            # Log the error but don't crash
-            if not ctx.obj.get('quiet', False):
-                rprint("[bold red]Warning:[/bold red] Example generation failed, skipping file write")
-
-        # 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}")
+    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:
+        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}"
 
-        # 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)
+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:
-            rprint("[bold red]No example code generated due to errors.[/bold red]")
+            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...")
 
-        return example_code, total_cost, model_name
+            # 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:
+                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:
+                        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.")
+        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)}")
-        sys.exit(1)
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        raise e

pdd/continue_generation.py

@@ -1,4 +1,5 @@
-from typing import Tuple
+from typing import Tuple, Optional
+import logging
 from rich.console import Console
 from rich.syntax import Syntax
 from pydantic import BaseModel, Field
@@ -9,6 +10,10 @@ from .unfinished_prompt import unfinished_prompt
 from . import EXTRACTION_STRENGTH, DEFAULT_TIME
 
 console = Console()
+logger = logging.getLogger(__name__)
+
+# Maximum number of generation loops to prevent infinite loops
+MAX_GENERATION_LOOPS = 20
 
 class TrimResultsStartOutput(BaseModel):
     explanation: str = Field(description="The explanation of how you determined what to cut out")
@@ -24,6 +29,7 @@ def continue_generation(
     strength: float,
     temperature: float,
     time: float = DEFAULT_TIME,
+    language: Optional[str] = None,
     verbose: bool = False
 ) -> Tuple[str, float, str]:
     """
@@ -78,16 +84,23 @@ 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
 
         # Step 4: Continue generation loop
-        while True:
+        while loop_count < MAX_GENERATION_LOOPS:
             loop_count += 1
             if verbose:
                 console.print(f"[cyan]Generation loop {loop_count}[/cyan]")
+            
+            # Check for maximum loops reached
+            if loop_count >= MAX_GENERATION_LOOPS:
+                logger.warning(f"Reached maximum generation loops ({MAX_GENERATION_LOOPS}), terminating")
+                console.print(f"[yellow]Warning: Reached maximum generation loops ({MAX_GENERATION_LOOPS}), terminating[/yellow]")
+                break
 
             # Generate continuation
             continue_response = llm_invoke(
@@ -99,26 +112,55 @@ def continue_generation(
                 strength=strength,
                 temperature=temperature,
                 time=time,
-                verbose=verbose
+                verbose=verbose,
+                language=language,
             )
             
             total_cost += continue_response['cost']
             model_name = continue_response['model_name']
             continue_result = continue_response['result']
 
-            # Check if generation is complete
-            last_chunk = code_block[-600:] if len(code_block) > 600 else code_block
-            _, is_finished, check_cost, _ = unfinished_prompt(
+            if verbose:
+                try:
+                    preview = (continue_result[:160] + '...') if isinstance(continue_result, str) and len(continue_result) > 160 else continue_result
+                except Exception:
+                    preview = "<non-str>"
+                console.print(f"[blue]Continue model:[/blue] {model_name}")
+                console.print(f"[blue]Continue preview:[/blue] {preview!r}")
+
+            # If the model produced no continuation, avoid an endless loop
+            if not isinstance(continue_result, str) or not continue_result.strip():
+                logger.warning("Empty continuation received; stopping to avoid loop.")
+                break
+
+            # Build prospective new block and check completeness on the updated tail
+            new_code_block = code_block + continue_result
+            last_chunk = new_code_block[-600:] if len(new_code_block) > 600 else new_code_block
+            reasoning, is_finished, check_cost, check_model = unfinished_prompt(
                 prompt_text=last_chunk,
                 strength=0.5,
                 temperature=0,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost += check_cost
 
+            if verbose:
+                console.print(f"[magenta]Tail length:[/magenta] {len(last_chunk)}")
+                # Show a safe, shortened representation of the tail
+                try:
+                    tail_preview = (last_chunk[-200:] if len(last_chunk) > 200 else last_chunk)
+                except Exception:
+                    tail_preview = "<unprintable tail>"
+                console.print(f"[magenta]Tail preview (last 200 chars):[/magenta]\n{tail_preview}")
+                console.print(f"[magenta]Unfinished check model:[/magenta] {check_model}")
+                console.print(f"[magenta]is_finished:[/magenta] {is_finished}")
+                console.print(f"[magenta]Reasoning:[/magenta] {reasoning}")
+
             if not is_finished:
-                code_block += continue_result
+                code_block = new_code_block
+                # Continue to next iteration
             else:
                 # Trim and append final continuation
                 trim_response = llm_invoke(
@@ -131,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
@@ -146,4 +189,4 @@ def continue_generation(
 
     except Exception as e:
         console.print(f"[bold red]Error in continue_generation: {str(e)}[/bold red]")
-        raise
+        raise

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',
+]