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

pdd/code_generator_main.py

@@ -1,6 +1,5 @@
 import os
 import re
-import asyncio
 import json
 import pathlib
 import shlex
@@ -21,16 +20,15 @@ from .construct_paths import construct_paths
 from .preprocess import preprocess as pdd_preprocess
 from .code_generator import code_generator as local_code_generator_func
 from .incremental_code_generator import incremental_code_generator as incremental_code_generator_func
-from .get_jwt_token import get_jwt_token, AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError
+from .core.cloud import CloudConfig
 from .python_env_detector import detect_host_python_executable
+from .architecture_sync import (
+    get_architecture_entry_for_prompt,
+    has_pdd_tags,
+    generate_tags_from_architecture,
+)
 
-# Environment variable names for Firebase/GitHub auth
-FIREBASE_API_KEY_ENV_VAR = "NEXT_PUBLIC_FIREBASE_API_KEY" 
-GITHUB_CLIENT_ID_ENV_VAR = "GITHUB_CLIENT_ID"
-PDD_APP_NAME = "PDD Code Generator"
-
-# Cloud function URL
-CLOUD_GENERATE_URL = "https://us-central1-prompt-driven-development.cloudfunctions.net/generateCode"
+# Cloud request timeout
 CLOUD_REQUEST_TIMEOUT = 400  # seconds
 
 console = Console()
@@ -46,6 +44,13 @@ def _parse_llm_bool(value: str) -> bool:
     else:
         return llm_str in {"1", "true", "yes", "on"}
 
+def _env_flag_enabled(name: str) -> bool:
+    """Return True when an env var is set to a truthy value."""
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
 # --- Git Helper Functions ---
 def _run_git_command(command: List[str], cwd: Optional[str] = None) -> Tuple[int, str, str]:
     """Runs a git command and returns (return_code, stdout, stderr)."""
@@ -762,7 +767,8 @@ def code_generator_main(
             if verbose:
                 console.print(Panel("Performing full code generation...", title="[blue]Mode[/blue]", expand=False))
             
-            current_execution_is_local = is_local_execution_preferred
+            cloud_only = _env_flag_enabled("PDD_CLOUD_ONLY") or _env_flag_enabled("PDD_NO_LOCAL_FALLBACK")
+            current_execution_is_local = is_local_execution_preferred and not cloud_only
             
             if not current_execution_is_local:
                 if verbose: console.print("Attempting cloud code generation...")
@@ -772,31 +778,22 @@ def code_generator_main(
                 processed_prompt_for_cloud = pdd_preprocess(processed_prompt_for_cloud, recursive=False, double_curly_brackets=True, exclude_keys=[])
                 if verbose: console.print(Panel(Text(processed_prompt_for_cloud, overflow="fold"), title="[cyan]Preprocessed Prompt for Cloud[/cyan]", expand=False))
                 
-                jwt_token: Optional[str] = None
-                try:
-                    firebase_api_key_val = os.environ.get(FIREBASE_API_KEY_ENV_VAR)
-                    github_client_id_val = os.environ.get(GITHUB_CLIENT_ID_ENV_VAR)
-
-                    if not firebase_api_key_val: raise AuthError(f"{FIREBASE_API_KEY_ENV_VAR} not set.")
-                    if not github_client_id_val: raise AuthError(f"{GITHUB_CLIENT_ID_ENV_VAR} not set.")
-
-                    jwt_token = asyncio.run(get_jwt_token(
-                        firebase_api_key=firebase_api_key_val,
-                        github_client_id=github_client_id_val,
-                        app_name=PDD_APP_NAME
-                    ))
-                except (AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError) as e:
-                    console.print(f"[yellow]Cloud authentication/token error: {e}. Falling back to local execution.[/yellow]")
-                    current_execution_is_local = True
-                except Exception as e:
-                    console.print(f"[yellow]Unexpected error during cloud authentication: {e}. Falling back to local execution.[/yellow]")
+                # Get JWT token via CloudConfig (handles both injected tokens and device flow)
+                jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
+
+                if not jwt_token:
+                    if cloud_only:
+                        console.print("[red]Cloud authentication failed.[/red]")
+                        raise click.UsageError("Cloud authentication failed")
+                    console.print("[yellow]Cloud authentication failed. Falling back to local execution.[/yellow]")
                     current_execution_is_local = True
 
                 if jwt_token and not current_execution_is_local:
                     payload = {"promptContent": processed_prompt_for_cloud, "language": language, "strength": strength, "temperature": temperature, "verbose": verbose}
                     headers = {"Authorization": f"Bearer {jwt_token}", "Content-Type": "application/json"}
+                    cloud_url = CloudConfig.get_endpoint_url("generateCode")
                     try:
-                        response = requests.post(CLOUD_GENERATE_URL, json=payload, headers=headers, timeout=CLOUD_REQUEST_TIMEOUT)
+                        response = requests.post(cloud_url, json=payload, headers=headers, timeout=CLOUD_REQUEST_TIMEOUT)
                         response.raise_for_status()
                         
                         response_data = response.json()
@@ -804,22 +801,71 @@ def code_generator_main(
                         total_cost = float(response_data.get("totalCost", 0.0))
                         model_name = response_data.get("modelName", "cloud_model")
 
+                        # Strip markdown code fences if present (cloud API returns fenced JSON)
+                        if generated_code_content and isinstance(language, str) and language.strip().lower() == "json":
+                            cleaned = generated_code_content.strip()
+                            if cleaned.startswith("```json"):
+                                cleaned = cleaned[7:]
+                            elif cleaned.startswith("```"):
+                                cleaned = cleaned[3:]
+                            if cleaned.endswith("```"):
+                                cleaned = cleaned[:-3]
+                            generated_code_content = cleaned.strip()
+
                         if not generated_code_content:
+                            if cloud_only:
+                                console.print("[red]Cloud execution returned no code.[/red]")
+                                raise click.UsageError("Cloud execution returned no code")
                             console.print("[yellow]Cloud execution returned no code. Falling back to local.[/yellow]")
                             current_execution_is_local = True
                         elif verbose:
                              console.print(Panel(f"Cloud generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Cloud Success[/green]", expand=False))
                     except requests.exceptions.Timeout:
+                        if cloud_only:
+                            console.print(f"[red]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s).[/red]")
+                            raise click.UsageError("Cloud execution timed out")
                         console.print(f"[yellow]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s). Falling back to local.[/yellow]")
                         current_execution_is_local = True
                     except requests.exceptions.HTTPError as e:
+                        status_code = e.response.status_code if e.response else 0
                         err_content = e.response.text[:200] if e.response else "No response content"
-                        console.print(f"[yellow]Cloud HTTP error ({e.response.status_code}): {err_content}. Falling back to local.[/yellow]")
-                        current_execution_is_local = True
+
+                        # Non-recoverable errors: do NOT fall back to local
+                        if status_code == 402:  # Insufficient credits
+                            try:
+                                error_data = e.response.json()
+                                current_balance = error_data.get("currentBalance", "unknown")
+                                estimated_cost = error_data.get("estimatedCost", "unknown")
+                                console.print(f"[red]Insufficient credits. Current balance: {current_balance}, estimated cost: {estimated_cost}[/red]")
+                            except Exception:
+                                console.print(f"[red]Insufficient credits: {err_content}[/red]")
+                            raise click.UsageError("Insufficient credits for cloud code generation")
+                        elif status_code == 401:  # Authentication error
+                            console.print(f"[red]Authentication failed: {err_content}[/red]")
+                            raise click.UsageError("Cloud authentication failed")
+                        elif status_code == 403:  # Authorization error (not approved)
+                            console.print(f"[red]Access denied: {err_content}[/red]")
+                            raise click.UsageError("Access denied - user not approved")
+                        elif status_code == 400:  # Validation error (e.g., empty prompt)
+                            console.print(f"[red]Invalid request: {err_content}[/red]")
+                            raise click.UsageError(f"Invalid request: {err_content}")
+                        else:
+                            # Recoverable errors (5xx, unexpected errors): fall back to local
+                            if cloud_only:
+                                console.print(f"[red]Cloud HTTP error ({status_code}): {err_content}[/red]")
+                                raise click.UsageError(f"Cloud HTTP error ({status_code}): {err_content}")
+                            console.print(f"[yellow]Cloud HTTP error ({status_code}): {err_content}. Falling back to local.[/yellow]")
+                            current_execution_is_local = True
                     except requests.exceptions.RequestException as e:
+                        if cloud_only:
+                            console.print(f"[red]Cloud network error: {e}[/red]")
+                            raise click.UsageError(f"Cloud network error: {e}")
                         console.print(f"[yellow]Cloud network error: {e}. Falling back to local.[/yellow]")
                         current_execution_is_local = True
                     except json.JSONDecodeError:
+                        if cloud_only:
+                            console.print("[red]Cloud returned invalid JSON.[/red]")
+                            raise click.UsageError("Cloud returned invalid JSON")
                         console.print("[yellow]Cloud returned invalid JSON. Falling back to local.[/yellow]")
                         current_execution_is_local = True
             
@@ -1006,6 +1052,23 @@ def code_generator_main(
                                 raise click.UsageError(f"LLM generation failed: {generated_code_content}")
                                 
                             parsed = json.loads(generated_code_content)
+
+                            # Fix common LLM mistake: unwrap arrays wrapped in objects
+                            # LLMs often return {"items": [...]} or {"type": "array", "items": [...]}
+                            # when the schema expects a plain array [...]
+                            output_schema = fm_meta.get("output_schema", {})
+                            if output_schema.get("type") == "array" and isinstance(parsed, dict):
+                                # Check for common wrapper patterns
+                                if "items" in parsed and isinstance(parsed["items"], list):
+                                    parsed = parsed["items"]
+                                    generated_code_content = json.dumps(parsed, indent=2)
+                                elif "data" in parsed and isinstance(parsed["data"], list):
+                                    parsed = parsed["data"]
+                                    generated_code_content = json.dumps(parsed, indent=2)
+                                elif "results" in parsed and isinstance(parsed["results"], list):
+                                    parsed = parsed["results"]
+                                    generated_code_content = json.dumps(parsed, indent=2)
+
                             if _is_architecture_template(fm_meta):
                                 parsed, repaired = _repair_architecture_interface_types(parsed)
                                 if repaired:
@@ -1024,7 +1087,30 @@ def code_generator_main(
             if output_path:
                 p_output = pathlib.Path(output_path)
                 p_output.parent.mkdir(parents=True, exist_ok=True)
-                p_output.write_text(generated_code_content, encoding="utf-8")
+
+                # Inject architecture metadata tags for .prompt files (reverse sync)
+                final_content = generated_code_content
+                if p_output.suffix == '.prompt':
+                    try:
+                        # Check if this prompt has an architecture entry
+                        arch_entry = get_architecture_entry_for_prompt(p_output.name)
+
+                        # Only inject tags if:
+                        # 1. Architecture entry exists
+                        # 2. Content doesn't already have PDD tags (preserve manual edits)
+                        if arch_entry and not has_pdd_tags(generated_code_content):
+                            tags = generate_tags_from_architecture(arch_entry)
+                            if tags:
+                                # Prepend tags to the generated content
+                                final_content = tags + '\n\n' + generated_code_content
+                                if verbose:
+                                    console.print("[info]Injected architecture metadata tags from architecture.json[/info]")
+                    except Exception as e:
+                        # Don't fail generation if tag injection fails
+                        if verbose:
+                            console.print(f"[yellow]Warning: Could not inject architecture tags: {e}[/yellow]")
+
+                p_output.write_text(final_content, encoding="utf-8")
                 if verbose or not quiet:
                     console.print(f"Generated code saved to: [green]{p_output.resolve()}[/green]")
                 # Safety net: ensure architecture HTML is generated post-write if applicable

pdd/commands/__init__.py

@@ -8,7 +8,10 @@ from .fix import fix
 from .modify import split, change, update
 from .maintenance import sync, auto_deps, setup
 from .analysis import detect_change, conflicts, bug, crash, trace
+from .connect import connect
+from .auth import auth_group
 from .misc import preprocess
+from .sessions import sessions
 from .report import report_core
 from .templates import templates_group
 from .utility import install_completion_cmd, verify
@@ -40,3 +43,6 @@ def register_commands(cli: click.Group) -> None:
     # The original code did: cli.commands["templates"] = templates_group
     # Using add_command is cleaner if it works for the structure.
     cli.add_command(templates_group)
+    cli.add_command(connect)
+    cli.add_command(auth_group)
+    cli.add_command(sessions)

pdd/commands/analysis.py

@@ -1,16 +1,25 @@
+from __future__ import annotations
+
 """
 Analysis commands (detect-change, conflicts, bug, crash, trace).
 """
+import os
 import click
-from typing import Optional, Tuple, List
+from typing import Optional, Tuple, List, Dict, Any
 
 from ..detect_change_main import detect_change_main
 from ..conflicts_main import conflicts_main
 from ..bug_main import bug_main
+from ..agentic_bug import run_agentic_bug
 from ..crash_main import crash_main
 from ..trace_main import trace_main
 from ..track_cost import track_cost
 from ..core.errors import handle_error
+from ..operation_log import log_operation
+
+def get_context_obj(ctx: click.Context) -> Dict[str, Any]:
+    """Safely retrieve the context object, defaulting to empty dict if None."""
+    return ctx.obj or {}
 
 @click.command("detect")
 @click.argument("files", nargs=-1, type=click.Path(exists=True, dir_okay=False))
@@ -24,8 +33,8 @@ from ..core.errors import handle_error
 @track_cost
 def detect_change(
     ctx: click.Context,
-    files: Tuple[str, ...],
-    output: Optional[str],
+    files: Tuple[str, ...] = (),
+    output: Optional[str] = None,
 ) -> Optional[Tuple[List, float, str]]:
     """Detect if prompts need to be changed based on a description.
     
@@ -46,10 +55,10 @@ def detect_change(
             output=output,
         )
         return result, total_cost, model_name
-    except click.Abort:
+    except (click.Abort, click.ClickException):
         raise
     except Exception as exception:
-        handle_error(exception, "detect", ctx.obj.get("quiet", False))
+        handle_error(exception, "detect", get_context_obj(ctx).get("quiet", False))
         return None
 
 
@@ -68,7 +77,7 @@ def conflicts(
     ctx: click.Context,
     prompt1: str,
     prompt2: str,
-    output: Optional[str],
+    output: Optional[str] = None,
 ) -> Optional[Tuple[List, float, str]]:
     """Check for conflicts between two prompt files."""
     try:
@@ -77,22 +86,24 @@ def conflicts(
             prompt1=prompt1,
             prompt2=prompt2,
             output=output,
-            verbose=ctx.obj.get("verbose", False),
+            verbose=get_context_obj(ctx).get("verbose", False),
         )
         return result, total_cost, model_name
-    except click.Abort:
+    except (click.Abort, click.ClickException):
         raise
     except Exception as exception:
-        handle_error(exception, "conflicts", ctx.obj.get("quiet", False))
+        handle_error(exception, "conflicts", get_context_obj(ctx).get("quiet", False))
         return None
 
 
 @click.command("bug")
-@click.argument("prompt_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("code_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("program_file", type=click.Path(exists=True, dir_okay=False))
-@click.argument("current_output", type=click.Path(exists=True, dir_okay=False))
-@click.argument("desired_output", type=click.Path(exists=True, dir_okay=False))
+@click.option(
+    "--manual",
+    is_flag=True,
+    default=False,
+    help="Run in manual mode requiring 5 positional file arguments.",
+)
+@click.argument("args", nargs=-1)
 @click.option(
     "--output",
     type=click.Path(writable=True),
@@ -103,37 +114,90 @@ def conflicts(
     "--language",
     type=str,
     default="Python",
-    help="Programming language for the unit test.",
+    help="Programming language for the unit test (Manual mode only).",
+)
+@click.option(
+    "--timeout-adder",
+    type=float,
+    default=0.0,
+    help="Additional seconds to add to each step's timeout (agentic mode only).",
+)
+@click.option(
+    "--no-github-state",
+    is_flag=True,
+    default=False,
+    help="Disable GitHub state persistence (agentic mode only).",
 )
 @click.pass_context
 @track_cost
 def bug(
     ctx: click.Context,
-    prompt_file: str,
-    code_file: str,
-    program_file: str,
-    current_output: str,
-    desired_output: str,
-    output: Optional[str],
-    language: str,
+    manual: bool = False,
+    args: Tuple[str, ...] = (),
+    output: Optional[str] = None,
+    language: str = "Python",
+    timeout_adder: float = 0.0,
+    no_github_state: bool = False,
 ) -> Optional[Tuple[str, float, str]]:
-    """Generate a unit test reproducing a bug from inputs and outputs."""
+    """Generate a unit test (manual) or investigate a bug (agentic).
+
+    Agentic Mode (default):
+        pdd bug ISSUE_URL
+
+    Manual Mode:
+        pdd bug --manual PROMPT_FILE CODE_FILE PROGRAM_FILE CURRENT_OUTPUT DESIRED_OUTPUT
+    """
     try:
-        result, total_cost, model_name = bug_main(
-            ctx=ctx,
-            prompt_file=prompt_file,
-            code_file=code_file,
-            program_file=program_file,
-            current_output=current_output,
-            desired_output=desired_output,
-            output=output,
-            language=language,
-        )
-        return result, total_cost, model_name
-    except click.Abort:
+        obj = get_context_obj(ctx)
+        if manual:
+            if len(args) != 5:
+                raise click.UsageError(
+                    "Manual mode requires 5 arguments: PROMPT_FILE CODE_FILE PROGRAM_FILE CURRENT_OUTPUT DESIRED_OUTPUT"
+                )
+            
+            # Validate files exist (replicating click.Path(exists=True))
+            for f in args:
+                if not os.path.exists(f):
+                    raise click.UsageError(f"File does not exist: {f}")
+                if os.path.isdir(f):
+                    raise click.UsageError(f"Path is a directory, not a file: {f}")
+
+            prompt_file, code_file, program_file, current_output, desired_output = args
+
+            result, total_cost, model_name = bug_main(
+                ctx=ctx,
+                prompt_file=prompt_file,
+                code_file=code_file,
+                program_file=program_file,
+                current_output=current_output,
+                desired_output=desired_output,
+                output=output,
+                language=language,
+            )
+            return result, total_cost, model_name
+        
+        else:
+            # Agentic mode
+            if len(args) != 1:
+                raise click.UsageError("Agentic mode requires exactly one argument: the GitHub Issue URL.")
+            
+            issue_url = args[0]
+            
+            success, message, cost, model, changed_files = run_agentic_bug(
+                issue_url=issue_url,
+                verbose=obj.get("verbose", False),
+                quiet=obj.get("quiet", False),
+                timeout_adder=timeout_adder,
+                use_github_state=not no_github_state,
+            )
+            
+            result_str = f"Success: {success}\nMessage: {message}\nChanged Files: {changed_files}"
+            return result_str, cost, model
+
+    except (click.Abort, click.ClickException):
         raise
     except Exception as exception:
-        handle_error(exception, "bug", ctx.obj.get("quiet", False))
+        handle_error(exception, "bug", get_context_obj(ctx).get("quiet", False))
         return None
 
 
@@ -173,6 +237,7 @@ def bug(
     help="Maximum cost allowed for the fixing process (default: 5.0).",
 )
 @click.pass_context
+@log_operation("crash", clears_run_report=True)
 @track_cost
 def crash(
     ctx: click.Context,
@@ -180,15 +245,15 @@ def crash(
     code_file: str,
     program_file: str,
     error_file: str,
-    output: Optional[str],
-    output_program: Optional[str],
-    loop: bool,
-    max_attempts: Optional[int],
-    budget: Optional[float],
+    output: Optional[str] = None,
+    output_program: Optional[str] = None,
+    loop: bool = False,
+    max_attempts: Optional[int] = None,
+    budget: Optional[float] = None,
 ) -> Optional[Tuple[str, float, str]]:
     """Analyze a crash and fix the code and program."""
     try:
-        # crash_main returns: success, final_code, final_program, attempts, cost, model
+        # crash_main returns: success, final_code, final_program, attempts, total_cost, model_name
         success, final_code, final_program, attempts, total_cost, model_name = crash_main(
             ctx=ctx,
             prompt_file=prompt_file,
@@ -204,10 +269,10 @@ def crash(
         # Return a summary string as the result for track_cost/CLI output
         result = f"Success: {success}, Attempts: {attempts}"
         return result, total_cost, model_name
-    except click.Abort:
+    except (click.Abort, click.ClickException):
         raise
     except Exception as exception:
-        handle_error(exception, "crash", ctx.obj.get("quiet", False))
+        handle_error(exception, "crash", get_context_obj(ctx).get("quiet", False))
         return None
 
 
@@ -228,7 +293,7 @@ def trace(
     prompt_file: str,
     code_file: str,
     code_line: int,
-    output: Optional[str],
+    output: Optional[str] = None,
 ) -> Optional[Tuple[str, float, str]]:
     """Trace execution flow back to the prompt."""
     try:
@@ -241,8 +306,8 @@ def trace(
             output=output,
         )
         return str(result), total_cost, model_name
-    except click.Abort:
+    except (click.Abort, click.ClickException):
         raise
     except Exception as exception:
-        handle_error(exception, "trace", ctx.obj.get("quiet", False))
-        return None
+        handle_error(exception, "trace", get_context_obj(ctx).get("quiet", False))
+        return None