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

pdd/prompts/insert_includes_LLM.prompt

@@ -63,142 +63,147 @@ if __name__ == "__main__":
 
         For running prompts with llm_invoke:
         <llm_invoke_example>
-            from pydantic import BaseModel, Field
-from pdd.llm_invoke import llm_invoke, _load_model_data, _select_model_candidates, LLM_MODEL_CSV_PATH, DEFAULT_BASE_MODEL
-from typing import List, Dict, Any
+            import os
+import sys
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+# Ensure the package is in the python path for this example
+# In a real installation, this would just be 'from pdd.llm_invoke import llm_invoke'
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from pdd.llm_invoke import llm_invoke
+
+console = Console()
+
+# --- Example 1: Simple Text Generation ---
+def example_simple_text():
+    console.print("[bold blue]--- Example 1: Simple Text Generation ---[/bold blue]")
+    
+    # Define a prompt template
+    prompt_template = "Explain the concept of {concept} to a {audience} in one sentence."
+    
+    # Define input variables
+    input_data = {
+        "concept": "quantum entanglement",
+        "audience": "5-year-old"
+    }
+
+    # Invoke the LLM
+    # strength=0.5 targets the 'base' model (usually a balance of cost/performance)
+    result = llm_invoke(
+        prompt=prompt_template,
+        input_json=input_data,
+        strength=0.5,
+        temperature=0.7,
+        verbose=True  # Set to True to see detailed logs about model selection and cost
+    )
 
-# Define a Pydantic model for structured output
-class Joke(BaseModel):
-    setup: str = Field(description="The setup of the joke")
-    punchline: str = Field(description="The punchline of the joke")
+    console.print(f"[green]Result:[/green] {result['result']}")
+    console.print(f"[dim]Model used: {result['model_name']} | Cost: ${result['cost']:.6f}[/dim]\n")
 
 
-def calculate_model_ranges(step: float = 0.001) -> List[Dict[str, Any]]:
-    """
-    Calculate the strength ranges for each model by sampling strength values.
+# --- Example 2: Structured Output with Pydantic ---
+class MovieReview(BaseModel):
+    title: str = Field(..., description="The title of the movie")
+    rating: int = Field(..., description="Rating out of 10")
+    summary: str = Field(..., description="A brief summary of the plot")
+    tags: List[str] = Field(..., description="List of genre tags")
 
-    Args:
-        step: The step size for sampling strength values (default 0.001)
+def example_structured_output():
+    console.print("[bold blue]--- Example 2: Structured Output (Pydantic) ---[/bold blue]")
 
-    Returns:
-        List of dicts with 'model', 'start', 'end', and 'midpoint' keys
-    """
-    model_df = _load_model_data(LLM_MODEL_CSV_PATH)
-
-    ranges = []
-    current_model = None
-    range_start = 0.0
-
-    # Sample strength values to find model boundaries
-    strength = 0.0
-    while strength <= 1.0:
-        candidates = _select_model_candidates(strength, DEFAULT_BASE_MODEL, model_df)
-        selected_model = candidates[0]['model'] if candidates else None
-
-        if current_model != selected_model:
-            if current_model is not None:
-                ranges.append({
-                    'model': current_model,
-                    'start': range_start,
-                    'end': round(strength - step, 3),
-                    'midpoint': round((range_start + strength - step) / 2, 3)
-                })
-            current_model = selected_model
-            range_start = strength
-
-        strength = round(strength + step, 3)
-
-    # Add the final range
-    if current_model is not None:
-        ranges.append({
-            'model': current_model,
-            'start': range_start,
-            'end': 1.0,
-            'midpoint': round((range_start + 1.0) / 2, 3)
-        })
-
-    return ranges
+    prompt = "Generate a review for a fictional sci-fi movie about {topic}."
+    input_data = {"topic": "time traveling cats"}
 
+    # Invoke with output_pydantic to enforce a schema
+    # strength=0.8 targets a higher-performance model (better at following schemas)
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=0.8,
+        output_pydantic=MovieReview,
+        temperature=0.5
+    )
 
-def main():
-    """
-    Main function to demonstrate the usage of `llm_invoke`.
+    # The 'result' key will contain an instance of the Pydantic model
+    review: MovieReview = result['result']
+    
+    console.print(f"[green]Title:[/green] {review.title}")
+    console.print(f"[green]Rating:[/green] {review.rating}/10")
+    console.print(f"[green]Tags:[/green] {', '.join(review.tags)}")
+    console.print(f"[dim]Model used: {result['model_name']}[/dim]\n")
+
+
+# --- Example 3: Batch Processing ---
+def example_batch_processing():
+    console.print("[bold blue]--- Example 3: Batch Processing ---[/bold blue]")
+
+    prompt = "What is the capital of {country}?"
+    
+    # List of inputs triggers batch mode
+    batch_inputs = [
+        {"country": "France"},
+        {"country": "Japan"},
+        {"country": "Brazil"}
+    ]
+
+    # use_batch_mode=True uses the provider's batch API if available/supported by LiteLLM
+    # strength=0.2 targets a cheaper/faster model
+    results = llm_invoke(
+        prompt=prompt,
+        input_json=batch_inputs,
+        use_batch_mode=True,
+        strength=0.2,
+        temperature=0.1
+    )
+
+    # In batch mode, 'result' is a list of strings (or objects)
+    for i, res in enumerate(results['result']):
+        console.print(f"[green]Input:[/green] {batch_inputs[i]['country']} -> [green]Output:[/green] {res}")
+    
+    console.print(f"[dim]Model used: {results['model_name']} | Total Cost: ${results['cost']:.6f}[/dim]\n")
+
+
+# --- Example 4: Reasoning / Thinking Time ---
+def example_reasoning():
+    console.print("[bold blue]--- Example 4: Reasoning / Thinking Time ---[/bold blue]")
+
+    # Some models (like Claude 3.7 or OpenAI o1/o3) support explicit thinking steps.
+    # Setting time > 0 enables this behavior based on the model's configuration in llm_model.csv.
+    
+    prompt = "Solve this riddle: {riddle}"
+    input_data = {"riddle": "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?"}
+
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=1.0,  # Target highest capability model
+        time=0.5,      # Request moderate thinking time/budget
+        verbose=True
+    )
+
+    console.print(f"[green]Answer:[/green] {result['result']}")
+    
+    # If the model supports it, thinking output is captured separately
+    if result.get('thinking_output'):
+        console.print(f"[yellow]Thinking Process:[/yellow] {result['thinking_output']}")
+    else:
+        console.print("[dim]No separate thinking output returned for this model.[/dim]")
 
-    Automatically calculates model ranges and runs each model once
-    at its midpoint strength value.
-    """
-    # Calculate model ranges automatically
-    print("Calculating model strength ranges...")
-    model_ranges = calculate_model_ranges()
-
-    # Print the calculated ranges
-    print("\n=== Model Strength Ranges ===")
-    for range_info in model_ranges:
-        print(f"{range_info['model']}: {range_info['start']:.3f} to {range_info['end']:.3f} (midpoint: {range_info['midpoint']:.3f})")
-
-    prompt = "Tell me a joke about {topic}"
-    input_json = {"topic": "programmers"}
-    temperature = 1
-    verbose = False
-
-    # Run each model once at its midpoint strength
-    print("\n=== Running Each Model Once ===")
-    for range_info in model_ranges:
-        model_name = range_info['model']
-        midpoint = range_info['midpoint']
-
-        print(f"\n--- Model: {model_name} (strength: {midpoint}) ---")
-
-        # Example 1: Unstructured Output
-        print("\n  Unstructured Output:")
-        response = llm_invoke(
-            prompt=prompt,
-            input_json=input_json,
-            strength=midpoint,
-            temperature=temperature,
-            verbose=verbose
-        )
-
-        print(f"  Result: {response['result']}")
-        print(f"  Cost: ${response['cost']:.6f}")
-        print(f"  Model Used: {response['model_name']}")
-
-        # Example 2: Structured Output with Pydantic Model
-        prompt_structured = (
-            "Generate a joke about {topic}. \n"
-            "Return it in this exact JSON format:\n"
-            "{{ \n"
-            '    "setup": "your setup here",\n'
-            '    "punchline": "your punchline here"\n'
-            "}}\n"
-            "Return ONLY the JSON with no additional text or explanation."
-        )
-        input_json_structured = {"topic": "data scientists"}
-        output_pydantic = Joke
-
-        print("\n  Structured Output:")
-        try:
-            response_structured = llm_invoke(
-                prompt=prompt_structured,
-                input_json=input_json_structured,
-                strength=midpoint,
-                temperature=temperature,
-                verbose=verbose,
-                output_pydantic=output_pydantic
-            )
-            print(f"  Result: {response_structured['result']}")
-            print(f"  Cost: ${response_structured['cost']:.6f}")
-            print(f"  Model Used: {response_structured['model_name']}")
-
-            # Access structured data
-            joke: Joke = response_structured['result']
-            print(f"\n  Joke Setup: {joke.setup}")
-            print(f"  Joke Punchline: {joke.punchline}")
-        except Exception as e:
-            print(f"  Error encountered during structured output: {e}")
 
 if __name__ == "__main__":
-    main()
+    # Ensure you have a valid .env file or environment variables set for API keys
+    # (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)
+    
+    try:
+        example_simple_text()
+        example_structured_output()
+        example_batch_processing()
+        example_reasoning()
+    except Exception as e:
+        console.print(f"[bold red]Error running examples:[/bold red] {e}")
         </llm_invoke_example>
     </internal_modules>
 </dependencies_to_insert>
@@ -252,142 +257,147 @@ if __name__ == "__main__":
 
         For running prompts with llm_invoke:
         <llm_invoke_example>
-            from pydantic import BaseModel, Field
-from pdd.llm_invoke import llm_invoke, _load_model_data, _select_model_candidates, LLM_MODEL_CSV_PATH, DEFAULT_BASE_MODEL
-from typing import List, Dict, Any
+            import os
+import sys
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+# Ensure the package is in the python path for this example
+# In a real installation, this would just be 'from pdd.llm_invoke import llm_invoke'
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from pdd.llm_invoke import llm_invoke
+
+console = Console()
+
+# --- Example 1: Simple Text Generation ---
+def example_simple_text():
+    console.print("[bold blue]--- Example 1: Simple Text Generation ---[/bold blue]")
+    
+    # Define a prompt template
+    prompt_template = "Explain the concept of {concept} to a {audience} in one sentence."
+    
+    # Define input variables
+    input_data = {
+        "concept": "quantum entanglement",
+        "audience": "5-year-old"
+    }
+
+    # Invoke the LLM
+    # strength=0.5 targets the 'base' model (usually a balance of cost/performance)
+    result = llm_invoke(
+        prompt=prompt_template,
+        input_json=input_data,
+        strength=0.5,
+        temperature=0.7,
+        verbose=True  # Set to True to see detailed logs about model selection and cost
+    )
 
-# Define a Pydantic model for structured output
-class Joke(BaseModel):
-    setup: str = Field(description="The setup of the joke")
-    punchline: str = Field(description="The punchline of the joke")
+    console.print(f"[green]Result:[/green] {result['result']}")
+    console.print(f"[dim]Model used: {result['model_name']} | Cost: ${result['cost']:.6f}[/dim]\n")
 
 
-def calculate_model_ranges(step: float = 0.001) -> List[Dict[str, Any]]:
-    """
-    Calculate the strength ranges for each model by sampling strength values.
+# --- Example 2: Structured Output with Pydantic ---
+class MovieReview(BaseModel):
+    title: str = Field(..., description="The title of the movie")
+    rating: int = Field(..., description="Rating out of 10")
+    summary: str = Field(..., description="A brief summary of the plot")
+    tags: List[str] = Field(..., description="List of genre tags")
 
-    Args:
-        step: The step size for sampling strength values (default 0.001)
+def example_structured_output():
+    console.print("[bold blue]--- Example 2: Structured Output (Pydantic) ---[/bold blue]")
 
-    Returns:
-        List of dicts with 'model', 'start', 'end', and 'midpoint' keys
-    """
-    model_df = _load_model_data(LLM_MODEL_CSV_PATH)
-
-    ranges = []
-    current_model = None
-    range_start = 0.0
-
-    # Sample strength values to find model boundaries
-    strength = 0.0
-    while strength <= 1.0:
-        candidates = _select_model_candidates(strength, DEFAULT_BASE_MODEL, model_df)
-        selected_model = candidates[0]['model'] if candidates else None
-
-        if current_model != selected_model:
-            if current_model is not None:
-                ranges.append({
-                    'model': current_model,
-                    'start': range_start,
-                    'end': round(strength - step, 3),
-                    'midpoint': round((range_start + strength - step) / 2, 3)
-                })
-            current_model = selected_model
-            range_start = strength
-
-        strength = round(strength + step, 3)
-
-    # Add the final range
-    if current_model is not None:
-        ranges.append({
-            'model': current_model,
-            'start': range_start,
-            'end': 1.0,
-            'midpoint': round((range_start + 1.0) / 2, 3)
-        })
-
-    return ranges
+    prompt = "Generate a review for a fictional sci-fi movie about {topic}."
+    input_data = {"topic": "time traveling cats"}
 
+    # Invoke with output_pydantic to enforce a schema
+    # strength=0.8 targets a higher-performance model (better at following schemas)
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=0.8,
+        output_pydantic=MovieReview,
+        temperature=0.5
+    )
 
-def main():
-    """
-    Main function to demonstrate the usage of `llm_invoke`.
+    # The 'result' key will contain an instance of the Pydantic model
+    review: MovieReview = result['result']
+    
+    console.print(f"[green]Title:[/green] {review.title}")
+    console.print(f"[green]Rating:[/green] {review.rating}/10")
+    console.print(f"[green]Tags:[/green] {', '.join(review.tags)}")
+    console.print(f"[dim]Model used: {result['model_name']}[/dim]\n")
+
+
+# --- Example 3: Batch Processing ---
+def example_batch_processing():
+    console.print("[bold blue]--- Example 3: Batch Processing ---[/bold blue]")
+
+    prompt = "What is the capital of {country}?"
+    
+    # List of inputs triggers batch mode
+    batch_inputs = [
+        {"country": "France"},
+        {"country": "Japan"},
+        {"country": "Brazil"}
+    ]
+
+    # use_batch_mode=True uses the provider's batch API if available/supported by LiteLLM
+    # strength=0.2 targets a cheaper/faster model
+    results = llm_invoke(
+        prompt=prompt,
+        input_json=batch_inputs,
+        use_batch_mode=True,
+        strength=0.2,
+        temperature=0.1
+    )
+
+    # In batch mode, 'result' is a list of strings (or objects)
+    for i, res in enumerate(results['result']):
+        console.print(f"[green]Input:[/green] {batch_inputs[i]['country']} -> [green]Output:[/green] {res}")
+    
+    console.print(f"[dim]Model used: {results['model_name']} | Total Cost: ${results['cost']:.6f}[/dim]\n")
+
+
+# --- Example 4: Reasoning / Thinking Time ---
+def example_reasoning():
+    console.print("[bold blue]--- Example 4: Reasoning / Thinking Time ---[/bold blue]")
+
+    # Some models (like Claude 3.7 or OpenAI o1/o3) support explicit thinking steps.
+    # Setting time > 0 enables this behavior based on the model's configuration in llm_model.csv.
+    
+    prompt = "Solve this riddle: {riddle}"
+    input_data = {"riddle": "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?"}
+
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=1.0,  # Target highest capability model
+        time=0.5,      # Request moderate thinking time/budget
+        verbose=True
+    )
+
+    console.print(f"[green]Answer:[/green] {result['result']}")
+    
+    # If the model supports it, thinking output is captured separately
+    if result.get('thinking_output'):
+        console.print(f"[yellow]Thinking Process:[/yellow] {result['thinking_output']}")
+    else:
+        console.print("[dim]No separate thinking output returned for this model.[/dim]")
 
-    Automatically calculates model ranges and runs each model once
-    at its midpoint strength value.
-    """
-    # Calculate model ranges automatically
-    print("Calculating model strength ranges...")
-    model_ranges = calculate_model_ranges()
-
-    # Print the calculated ranges
-    print("\n=== Model Strength Ranges ===")
-    for range_info in model_ranges:
-        print(f"{range_info['model']}: {range_info['start']:.3f} to {range_info['end']:.3f} (midpoint: {range_info['midpoint']:.3f})")
-
-    prompt = "Tell me a joke about {topic}"
-    input_json = {"topic": "programmers"}
-    temperature = 1
-    verbose = False
-
-    # Run each model once at its midpoint strength
-    print("\n=== Running Each Model Once ===")
-    for range_info in model_ranges:
-        model_name = range_info['model']
-        midpoint = range_info['midpoint']
-
-        print(f"\n--- Model: {model_name} (strength: {midpoint}) ---")
-
-        # Example 1: Unstructured Output
-        print("\n  Unstructured Output:")
-        response = llm_invoke(
-            prompt=prompt,
-            input_json=input_json,
-            strength=midpoint,
-            temperature=temperature,
-            verbose=verbose
-        )
-
-        print(f"  Result: {response['result']}")
-        print(f"  Cost: ${response['cost']:.6f}")
-        print(f"  Model Used: {response['model_name']}")
-
-        # Example 2: Structured Output with Pydantic Model
-        prompt_structured = (
-            "Generate a joke about {topic}. \n"
-            "Return it in this exact JSON format:\n"
-            "{{ \n"
-            '    "setup": "your setup here",\n'
-            '    "punchline": "your punchline here"\n'
-            "}}\n"
-            "Return ONLY the JSON with no additional text or explanation."
-        )
-        input_json_structured = {"topic": "data scientists"}
-        output_pydantic = Joke
-
-        print("\n  Structured Output:")
-        try:
-            response_structured = llm_invoke(
-                prompt=prompt_structured,
-                input_json=input_json_structured,
-                strength=midpoint,
-                temperature=temperature,
-                verbose=verbose,
-                output_pydantic=output_pydantic
-            )
-            print(f"  Result: {response_structured['result']}")
-            print(f"  Cost: ${response_structured['cost']:.6f}")
-            print(f"  Model Used: {response_structured['model_name']}")
-
-            # Access structured data
-            joke: Joke = response_structured['result']
-            print(f"\n  Joke Setup: {joke.setup}")
-            print(f"  Joke Punchline: {joke.punchline}")
-        except Exception as e:
-            print(f"  Error encountered during structured output: {e}")
 
 if __name__ == "__main__":
-    main()
+    # Ensure you have a valid .env file or environment variables set for API keys
+    # (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)
+    
+    try:
+        example_simple_text()
+        example_structured_output()
+        example_batch_processing()
+        example_reasoning()
+    except Exception as e:
+        console.print(f"[bold red]Error running examples:[/bold red] {e}")
         </llm_invoke_example>
     </internal_modules>
 

pdd/prompts/prompt_code_diff_LLM.prompt

@@ -0,0 +1,119 @@
+# prompt_code_diff_LLM.prompt
+
+You are a strict code analyst evaluating whether a PROMPT can REGENERATE the CODE.
+
+CRITICAL QUESTION: If an LLM only had this prompt, could it produce code that passes the same tests?
+
+PROMPT/REQUIREMENTS (with line numbers):
+```
+{prompt_numbered}
+```
+
+CODE (with line numbers):
+```
+{code_numbered}
+```
+
+## Analysis Focus
+
+**Be STRICT and PESSIMISTIC.** Your job is to find gaps that would cause regeneration failures.
+
+1. **Regeneration Risk Analysis**: Identify ALL code knowledge NOT in the prompt:
+   - Magic values, constants, thresholds (e.g., timeout=30, retry=3, buffer_size=4096)
+   - Specific algorithms or implementation approaches chosen
+   - Edge case handling not mentioned in prompt
+   - Error messages, status codes, specific exceptions
+   - API contracts, data formats, field names
+   - Dependencies, imports, library-specific patterns
+   - Performance optimizations or workarounds
+   - Business logic details embedded in code
+
+2. **Hidden Knowledge Detection**: Code often contains "tribal knowledge" that developers added but never documented:
+   - Why was THIS approach chosen over alternatives?
+   - What bugs or edge cases does this code handle that aren't obvious?
+   - What assumptions does the code make about inputs/environment?
+
+3. **Test Failure Prediction**: Would regenerated code likely fail tests because:
+   - Exact values/strings don't match expectations?
+   - Edge cases aren't handled the same way?
+   - API contracts differ from what tests expect?
+
+## Response Format
+
+Respond with a JSON object:
+
+1. "overallScore": integer 0-100
+   - 90-100: Prompt could regenerate code that passes tests
+   - 70-89: Minor details missing, regeneration might work with luck
+   - 50-69: Significant gaps, regeneration would likely fail some tests
+   - 0-49: Major knowledge missing, regeneration would definitely fail
+
+2. "canRegenerate": boolean - Conservative assessment: could this prompt produce working code?
+
+3. "regenerationRisk": "low", "medium", "high", or "critical"
+   - "low": Prompt captures all essential details
+   - "medium": Some implementation details missing but core logic documented
+   - "high": Significant undocumented behavior that would differ on regeneration
+   - "critical": Code has major features/logic not in prompt at all
+
+4. "summary": 1-2 sentences on regeneration viability, be direct about risks
+
+5. "sections": array of PROMPT requirement sections, each with:
+   - "id": unique string like "req_1", "req_2"
+   - "promptRange": {{"startLine": int, "endLine": int, "text": "excerpt"}}
+   - "codeRanges": array of {{"startLine": int, "endLine": int, "text": "excerpt"}} (empty if missing)
+   - "status": "matched", "partial", or "missing"
+   - "matchConfidence": 0-100
+   - "semanticLabel": descriptive label like "Error Handling", "Input Validation"
+   - "notes": REQUIRED explanation - be specific about what's missing or at risk
+
+6. "codeSections": array of CODE sections NOT adequately documented in prompt:
+   - "id": unique string like "code_1", "code_2"
+   - "promptRange": {{"startLine": int, "endLine": int, "text": "excerpt"}} (empty if undocumented)
+   - "codeRanges": array of {{"startLine": int, "endLine": int, "text": "excerpt"}}
+   - "status": "matched", "partial", or "extra"
+   - "matchConfidence": 0-100
+   - "semanticLabel": descriptive label
+   - "notes": REQUIRED - explain what knowledge would be LOST on regeneration
+     * For "extra": "REGENERATION RISK: [specific feature/value/logic] is not in prompt and would be lost or different"
+     * For "partial": "INCOMPLETE: Prompt mentions [X] but doesn't specify [critical detail Y]"
+
+7. "hiddenKnowledge": array of objects describing undocumented code knowledge:
+   - "type": "magic_value" | "algorithm_choice" | "edge_case" | "error_handling" | "api_contract" | "optimization" | "business_logic" | "assumption"
+   - "location": {{"startLine": int, "endLine": int}}
+   - "description": what the code knows that the prompt doesn't say
+   - "regenerationImpact": "would_differ" | "would_fail" | "might_work"
+   - "suggestedPromptAddition": what to add to the prompt to capture this
+
+8. "lineMappings": array of line-level mappings:
+   - "promptLine": int
+   - "codeLines": array of ints
+   - "matchType": "exact", "semantic", "partial", "none"
+
+9. "stats": {{
+   "totalRequirements": int,
+   "matchedRequirements": int,
+   "missingRequirements": int,
+   "totalCodeFeatures": int,
+   "documentedFeatures": int,
+   "undocumentedFeatures": int,
+   "promptToCodeCoverage": float,
+   "codeToPromptCoverage": float,
+   "hiddenKnowledgeCount": int,
+   "criticalGaps": int
+}}
+
+10. "missing": array of strings - requirements in prompt not implemented
+11. "extra": array of strings - CRITICAL: code features that would be LOST on regeneration
+12. "suggestions": array of specific additions to make to the prompt to enable regeneration
+
+## Strictness Guidelines
+
+- **Assume regeneration WILL differ** unless the prompt explicitly specifies behavior
+- A function that "handles errors" in the prompt might handle them DIFFERENTLY on regeneration
+- Constants, timeouts, retry counts, buffer sizes - if not in prompt, they WILL be different
+- Specific error messages, log formats, status codes - WILL be different unless specified
+- Algorithm choices (e.g., quicksort vs mergesort, BFS vs DFS) - WILL be different unless specified
+- The goal is to make the prompt complete enough that ANY competent LLM would produce equivalent code
+- Mark as "extra" anything in code that prompt doesn't EXPLICITLY require
+- When in doubt, mark it as a gap - false positives are better than missed risks