pdd-cli 0.0.49__py3-none-any.whl → 0.0.50__py3-none-any.whl

pdd/load_prompt_template.py

@@ -23,18 +23,39 @@ def load_prompt_template(prompt_name: str) -> Optional[str]:
         print_formatted("[red]Unexpected error loading prompt template[/red]")
         return None
 
-    # Step 1: Get project path from environment variable
-    project_path = os.getenv('PDD_PATH')
-    if not project_path:
-        print_formatted("[red]PDD_PATH environment variable is not set[/red]")
-        return None
+    # Step 1: Get project path from environment variable (preferred),
+    # else fall back to auto-detect based on this module's location or CWD.
+    project_path_env = os.getenv('PDD_PATH')
+    candidate_paths = []
+    if project_path_env:
+        candidate_paths.append(Path(project_path_env))
+
+    # Fallback 1: repository root inferred from this module (pdd/ => repo root)
+    try:
+        module_root = Path(__file__).resolve().parent  # pdd/
+        repo_root = module_root.parent                 # repo root
+        candidate_paths.append(repo_root)
+    except Exception:
+        pass
 
-    # Construct the full path to the prompt file
-    prompt_path = Path(project_path) / 'prompts' / f"{prompt_name}.prompt"
+    # Fallback 2: current working directory
+    candidate_paths.append(Path.cwd())
+
+    # Build candidate prompt paths to try in order
+    prompt_candidates = [cp / 'prompts' / f"{prompt_name}.prompt" for cp in candidate_paths]
 
     # Step 2: Load and return the prompt template
-    if not prompt_path.exists():
-        print_formatted(f"[red]Prompt file not found: {prompt_path}[/red]")
+    prompt_path: Optional[Path] = None
+    for candidate in prompt_candidates:
+        if candidate.exists():
+            prompt_path = candidate
+            break
+
+    if prompt_path is None:
+        tried = "\n".join(str(c) for c in prompt_candidates)
+        print_formatted(
+            f"[red]Prompt file not found in any candidate locations for '{prompt_name}'. Tried:\n{tried}[/red]"
+        )
         return None
 
     try:

pdd/pdd_completion.fish

@@ -27,7 +27,7 @@ complete -c pdd -n "__fish_use_subcommand" -a conflicts -d "Analyze conflicts be
 complete -c pdd -n "__fish_use_subcommand" -a crash -d "Fix code causing program crash"
 complete -c pdd -n "__fish_use_subcommand" -a trace -d "Trace code line to prompt"
 complete -c pdd -n "__fish_use_subcommand" -a bug -d "Generate unit test from bug report"
-complete -c pdd -n "__fish_use_subcommand" -a auto-deps -d "Analyze and insert dependencies"
+complete -c pdd -n "__fish_use_subcommand" -a auto-deps -d "Analyze and insert dependencies from directory or glob"
 complete -c pdd -n "__fish_use_subcommand" -a verify -d "Verify functional correctness using LLM judgment"
 
 # Command-specific completions
@@ -131,4 +131,4 @@ complete -c pdd -n "__fish_seen_subcommand_from generate example test preprocess
 complete -c pdd -n "__fish_seen_subcommand_from generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -a "(__fish_complete_suffix .log .txt .csv)"
 
 # Help completion
-complete -c pdd -n "__fish_seen_subcommand_from help" -a "generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -d "Show help for specific command"
+complete -c pdd -n "__fish_seen_subcommand_from help" -a "generate example test preprocess fix split change update detect conflicts crash trace bug auto-deps verify" -d "Show help for specific command"

pdd/pdd_completion.zsh

@@ -349,7 +349,7 @@ _pdd_bug() {
 #   --force-scan
 # Args:
 #   1: PROMPT_FILE
-#   2: DIRECTORY_PATH
+#   2: DIRECTORY_PATH (directory or glob pattern)
 _pdd_auto_deps() {
   _arguments -s \
     $_pdd_global_opts \
@@ -357,7 +357,7 @@ _pdd_auto_deps() {
     '--csv=[CSV file for dependency info (default: project_dependencies.csv).]:filename:_files' \
     '--force-scan[Force rescanning of all potential dependency files.]' \
     '1:prompt-file:_files' \
-    '2:directory:_files -/' \
+    '2:directory-or-glob:_files -/' \
     '*:filename:_files'
 }
 
@@ -410,7 +410,7 @@ _pdd() {
     'crash:Fix errors in a code module and its calling program'
     'trace:Find the prompt file line number associated with a code line'
     'bug:Generate a unit test based on incorrect vs desired outputs'
-    'auto-deps:Analyze a prompt file and directory for needed dependencies'
+    'auto-deps:Analyze a prompt and include deps from a directory or glob'
     'verify:Verify functional correctness using LLM judgment and iteratively fix'
   )
 
@@ -487,4 +487,4 @@ else
   echo >&2 "Warning: Could not register pdd completion. Make sure ZSH completion system is working."
 fi
 
-# End of pdd_completion.zsh
+# End of pdd_completion.zsh

pdd/postprocess.py

@@ -3,7 +3,7 @@ from rich import print
 from pydantic import BaseModel, Field
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
-from . import DEFAULT_TIME
+from . import DEFAULT_TIME, DEFAULT_STRENGTH
 
 class ExtractedCode(BaseModel):
     """Pydantic model for the extracted code."""
@@ -36,7 +36,7 @@ def postprocess_0(text: str) -> str:
 def postprocess(
     llm_output: str,
     language: str,
-    strength: float = 0.9,
+    strength: float = DEFAULT_STRENGTH,
     temperature: float = 0,
     time: float = DEFAULT_TIME,
     verbose: bool = False

pdd/prompts/extract_prompt_update_LLM.prompt

@@ -1,14 +1,13 @@
-% You are an expert Software Engineer. Your goal is to extract the updated prompt from the LLM output.
+% You are an expert Software Engineer. Your goal is to extract the updated prompt from the LLM output in JSON format.
 
 % Here is the generated llm_output: <llm_output>{llm_output}</llm_output>
 
-% The LLM output contains the modified prompt that will generate the modified code, possibly with some additional commentary or explanation.
-% Your task is to identify and extract ONLY the modified prompt itself, without adding any JSON structure or additional formatting.
+% The LLM output contains the modified prompt that will generate the modified code, possibly with some additional commentary or explanation. Your task is to identify and extract ONLY the modified prompt itself, without adding any additional formatting.
 
 % Ensure you:
-% 1. Remove any "# Modified Prompt" headers or similar text that isn't part of the actual prompt
-% 2. Preserve all markdown, code blocks, and formatting within the actual prompt
-% 3. Don't add any explanatory text, JSON wrappers, or your own commentary
-% 4. Return only the text that constitutes the actual prompt
+  1. Remove any "# Modified Prompt" headers or similar text that isn't part of the actual prompt
+  2. Preserve all markdown, code blocks, and formatting within the actual prompt
+  3. Don't add any explanatory text, JSON wrappers, or your own commentary
+  4. Return only the text that constitutes the actual prompt
 
-% The "modified_prompt" should be the complete, standalone prompt that could be used directly to generate the modified code.
+% The "modified_prompt" JSON key should be the complete, standalone prompt that could be used directly to generate the modified code.

pdd/prompts/insert_includes_LLM.prompt

@@ -75,8 +75,8 @@ def main():
     temperature = 1
     verbose = False
     
-    strength = 0.5
-    while strength <= 0.5:
+    strength = 0.0
+    while strength <= 1:
         print(f"\nStrength: {strength}")
         
         # Example 1: Unstructured Output
@@ -215,8 +215,8 @@ def main():
     temperature = 1
     verbose = False
     
-    strength = 0.5
-    while strength <= 0.5:
+    strength = 0.0
+    while strength <= 1:
         print(f"\nStrength: {strength}")
         
         # Example 1: Unstructured Output

pdd/prompts/unfinished_prompt_LLM.prompt

@@ -1,18 +1,102 @@
 % You are tasked with determining whether a given prompt has finished outputting everything or if it still needs to continue. This is crucial for ensuring that all necessary information has been provided before proceeding with further actions. You will often be provided the last few hundred characters of the prompt_text to analyze and determine if it appears to be complete or if it seems to be cut off or unfinished. You are just looking at the prompt_text and not the entire prompt file. The beginning part of the prompt_text is not always provided, so you will need to make a judgment based on the text you are given.
 
+% IMPORTANT:
+%  - The prompt_text may contain code in various languages without Markdown fences.
+%  - Do NOT require triple backticks for completeness; judge the code/text itself.
+%  - Prefer concrete syntactic signals of completeness over stylistic ones.
+
 % Here is the prompt text to analyze:
 <prompt_text>
     {PROMPT_TEXT}
 </prompt_text>
 
+% Optional language hint (may be empty or missing). If not provided, infer the language from the text:
+<language>
+    {LANGUAGE}
+</language>
+
 % Carefully examine the provided prompt text and determine if it appears to be complete or if it seems to be cut off or unfinished. Consider the following factors:
     1. Sentence structure: Are all sentences grammatically complete?
     2. Content flow: Does the text end abruptly or does it have a natural conclusion?
     3. Context: Based on the content, does it seem like all necessary information has been provided?
     4. Formatting: Are there any unclosed parentheses, quotation marks, or other formatting issues that suggest incompleteness?
 
+% Multi-language code completeness heuristics (apply when text looks like code):
+    - If the text forms a syntactically complete module/snippet for the language, treat it as finished (even without Markdown fences).
+    - Generic signals across languages:
+        * Balanced delimiters: (), [], {{}}, quotes, and block comments are closed.
+        * No mid-token/mid-statement tail: it does not end on `return a +`, `a =`, `def foo(`, `function f(`, trailing `.`, `->`, `::`, trailing `,`, or a line-continuation like `\\`.
+        * Block closure: constructs that open a block are closed (e.g., Python indentation after `:`, or matching `{{}}` in C/Java/JS/TS/Go).
+    - Language specifics (use LANGUAGE if given; otherwise infer from the text):
+        * Python: colon-introduced blocks closed; indentation consistent; triple-quoted strings balanced.
+        * JS/TS: braces and parentheses balanced; no dangling `export`/`import` without a following specifier; `/* ... */` comments closed.
+        * Java/C/C++/C#: braces and parentheses balanced; string/char literals closed; block comments closed.
+        * Go: braces balanced; no dangling keyword indicating an unfinished clause.
+        * HTML/XML: tags properly nested/closed; attributes properly quoted; no unfinished `<tag` or dangling `</`.
+    - If this is only the tail of a longer file, mark finished when the tail itself is syntactically complete and does not indicate a dangling continuation.
+
 % Provide your reasoning for why you believe the prompt is complete or incomplete.
 
 % Output a JSON object with two keys:
     1. "reasoning": A string containing your structured reasoning
-    2. "is_finished": A boolean value (true if the prompt is complete, false if it's incomplete)
+    2. "is_finished": A boolean value (true if the prompt is complete, false if it's incomplete)
+
+% Examples (concise):
+<examples>
+  <example1>
+    <input>
+      <prompt_text>
+        def add(a, b):\n    return a + b\n
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "Python code parses; blocks and quotes are closed; ends on a complete return statement.", "is_finished": true}}
+    </output>
+  </example1>
+  <example2>
+    <input>
+      <prompt_text>
+        def add(a, b):\n    return a +
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "Ends mid-expression (`return a +`), indicates unfinished statement.", "is_finished": false}}
+    </output>
+  </example2>
+  <example3>
+    <input>
+      <prompt_text>
+        function add(a, b) {{\n  return a + b;\n}}\n
+      </prompt_text>
+      <language>
+        JavaScript
+      </language>
+    </input>
+    <output>
+      {{"reasoning": "JS braces and parentheses balanced; ends at a statement boundary; no dangling tokens.", "is_finished": true}}
+    </output>
+  </example3>
+  <example4>
+    <input>
+      <prompt_text>
+        <div class=\"box\">Hello
+      </prompt_text>
+      <language>
+        HTML
+      </language>
+    </input>
+    <output>
+      {{"reasoning": "HTML tag not closed (missing </div>); attribute quotes OK but element is unclosed.", "is_finished": false}}
+    </output>
+  </example4>
+  <example5>
+    <input>
+      <prompt_text>
+        class C:\n            def f(self):\n                x = 1\n
+      </prompt_text>
+    </input>
+    <output>
+      {{"reasoning": "All blocks properly indented and closed in the visible tail; no dangling colon blocks or open delimiters; tail is syntactically complete.", "is_finished": true}}
+    </output>
+  </example5>
+</examples>

pdd/summarize_directory.py

@@ -131,8 +131,21 @@ def summarize_directory(
                 raise ValueError("Invalid CSV file format.")
             existing_data = parse_existing_csv(csv_file, verbose)
 
+        # Expand directory_path: support plain directories or glob patterns
+        try:
+            normalized_input = normalize_path(directory_path)
+        except Exception:
+            normalized_input = directory_path
+
+        if os.path.isdir(normalized_input):
+            # Recursively include all files under the directory
+            search_pattern = os.path.join(normalized_input, "**", "*")
+        else:
+            # Treat as a glob pattern (may be a single file path too)
+            search_pattern = directory_path
+
         # Get list of files first to ensure consistent order
-        files = sorted(glob.glob(directory_path, recursive=True))
+        files = sorted(glob.glob(search_pattern, recursive=True))
         if not files:
             if verbose:
                 print("[yellow]No files found.[/yellow]")
@@ -224,4 +237,4 @@ def summarize_directory(
 
     except Exception as e:
         print(f"[red]An error occurred: {str(e)}[/red]")
-        raise
+        raise

pdd/trace.py

@@ -3,6 +3,7 @@ from rich import print
 from rich.console import Console
 from pydantic import BaseModel, Field
 import difflib
+import re
 from .load_prompt_template import load_prompt_template
 from .preprocess import preprocess
 from .llm_invoke import llm_invoke
@@ -102,29 +103,148 @@ def trace(
         # Step 7: Find matching line in prompt file using fuzzy matching
         prompt_lines = prompt_file.splitlines()
         best_match = None
-        highest_ratio = 0
+        highest_ratio = 0.0
 
         if verbose:
             console.print(f"Searching for line: {prompt_line_str}")
 
-        normalized_search = prompt_line_str.strip()
+        # Robust normalization for comparison
+        def normalize_text(s: str) -> str:
+            if s is None:
+                return ""
+            s = s.replace("\u201c", '"').replace("\u201d", '"')  # smart double quotes → straight
+            s = s.replace("\u2018", "'").replace("\u2019", "'")  # smart single quotes → straight
+            s = s.replace("\u00A0", " ")  # non-breaking space → space
+            s = re.sub(r"\s+", " ", s.strip())  # collapse whitespace
+            return s
+
+        # If the model echoed wrapper tags like <llm_output>...</llm_output>, extract inner text
+        raw_search = prompt_line_str
+        try:
+            m = re.search(r"<\s*llm_output\s*>(.*?)<\s*/\s*llm_output\s*>", raw_search, flags=re.IGNORECASE | re.DOTALL)
+            if m:
+                raw_search = m.group(1)
+        except Exception:
+            pass
+
+        normalized_search = normalize_text(raw_search).casefold()
+        best_candidate_idx = None
+        best_candidate_len = 0
 
         for i, line in enumerate(prompt_lines, 1):
-            normalized_line = line.strip()
+            normalized_line = normalize_text(line).casefold()
+            line_len = len(normalized_line)
+
+            # Base similarity
             ratio = difflib.SequenceMatcher(None, normalized_search, normalized_line).ratio()
 
+            # Boost if one contains the other, but avoid trivial/short lines
+            if normalized_search and line_len >= 8:
+                shorter = min(len(normalized_search), line_len)
+                longer = max(len(normalized_search), line_len)
+                length_ratio = shorter / longer if longer else 0.0
+                if length_ratio >= 0.4 and (
+                    normalized_search in normalized_line or normalized_line in normalized_search
+                ):
+                    ratio = max(ratio, 0.999)
+
             if verbose:
                 console.print(f"Line {i}: '{line}' - Match ratio: {ratio}")
 
-            # Increase threshold to 0.9 for more precise matching
-            if ratio > highest_ratio and ratio > 0.9:
-                # Additional check for exact content match after normalization
-                if normalized_search == normalized_line:
+            # Track best candidate overall, skipping empty lines
+            if line_len > 0:
+                if ratio > highest_ratio:
                     highest_ratio = ratio
-                    best_match = i
-                    break  # Exit on exact match
-                highest_ratio = ratio
+                    best_candidate_idx = i
+                    best_candidate_len = line_len
+                elif abs(ratio - highest_ratio) < 1e-6 and best_candidate_idx is not None:
+                    # Tie-breaker: prefer longer normalized line
+                    if line_len > best_candidate_len:
+                        best_candidate_idx = i
+                        best_candidate_len = line_len
+
+            # Early exit on exact normalized equality
+            if normalized_search == normalized_line:
                 best_match = i
+                highest_ratio = 1.0
+                break
+
+        # Decide on acceptance thresholds
+        primary_threshold = 0.8  # lowered threshold for normal acceptance
+        fallback_threshold = 0.6  # low-confidence fallback threshold
+
+        if best_match is None and best_candidate_idx is not None:
+            if highest_ratio >= primary_threshold:
+                best_match = best_candidate_idx
+            elif highest_ratio >= fallback_threshold:
+                best_match = best_candidate_idx
+                if verbose:
+                    console.print(
+                        f"[yellow]Low-confidence match selected (ratio={highest_ratio:.3f}).[/yellow]"
+                    )
+
+        # Step 7b: Multi-line window matching (sizes 2 and 3) if no strong single-line match
+        if (best_match is None) or (highest_ratio < primary_threshold):
+            if verbose:
+                console.print("[blue]No strong single-line match; trying multi-line windows...[/blue]")
+
+            win_best_ratio = 0.0
+            win_best_idx: Optional[int] = None
+            win_best_size = 0
+
+            for window_size in (2, 3):
+                if len(prompt_lines) < window_size:
+                    continue
+                for start_idx in range(1, len(prompt_lines) - window_size + 2):
+                    window_lines = prompt_lines[start_idx - 1 : start_idx - 1 + window_size]
+                    window_text = " ".join(window_lines)
+                    normalized_window = normalize_text(window_text).casefold()
+                    seg_len = len(normalized_window)
+                    if seg_len == 0:
+                        continue
+
+                    ratio = difflib.SequenceMatcher(None, normalized_search, normalized_window).ratio()
+
+                    # Containment boost under similar length condition
+                    shorter = min(len(normalized_search), seg_len)
+                    longer = max(len(normalized_search), seg_len)
+                    length_ratio = (shorter / longer) if longer else 0.0
+                    if (
+                        normalized_search
+                        and seg_len >= 8
+                        and length_ratio >= 0.4
+                        and (
+                            normalized_search in normalized_window
+                            or normalized_window in normalized_search
+                        )
+                    ):
+                        ratio = max(ratio, 0.999)
+
+                    if verbose:
+                        console.print(
+                            f"Window {start_idx}-{start_idx+window_size-1}: ratio={ratio}"
+                        )
+
+                    # Track best window, prefer higher ratio; tie-breaker: larger window, then longer segment
+                    if ratio > win_best_ratio + 1e-6 or (
+                        abs(ratio - win_best_ratio) < 1e-6
+                        and (window_size > win_best_size or (window_size == win_best_size and seg_len > 0))
+                    ):
+                        win_best_ratio = ratio
+                        win_best_idx = start_idx
+                        win_best_size = window_size
+
+            if win_best_idx is not None and win_best_ratio > highest_ratio:
+                if win_best_ratio >= primary_threshold:
+                    best_match = win_best_idx
+                    highest_ratio = win_best_ratio
+                elif win_best_ratio >= fallback_threshold and best_match is None:
+                    best_match = win_best_idx
+                    highest_ratio = win_best_ratio
+                    if verbose:
+                        console.print(
+                            f"[yellow]Low-confidence multi-line match selected (ratio={win_best_ratio:.3f}).[/yellow]"
+                        )
 
         # Step 8: Return results
         if verbose:
@@ -136,4 +256,4 @@ def trace(
 
     except Exception as e:
         console.print(f"[bold red]Error in trace function: {str(e)}[/bold red]")
-        return None, 0.0, ""
+        return None, 0.0, ""

pdd/trace_main.py

@@ -5,7 +5,7 @@ import os
 import logging
 from .construct_paths import construct_paths
 from .trace import trace
-from . import DEFAULT_TIME, DEFAULT_STRENGTH
+from . import DEFAULT_TIME, DEFAULT_STRENGTH, DEFAULT_TEMPERATURE
 logging.basicConfig(level=logging.WARNING)
 logger = logging.getLogger(__name__)
 
@@ -50,7 +50,7 @@ def trace_main(ctx: click.Context, prompt_file: str, code_file: str, code_line:
 
         # Perform trace analysis
         strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
-        temperature = ctx.obj.get('temperature', 0.0)
+        temperature = ctx.obj.get('temperature', DEFAULT_TEMPERATURE)
         time = ctx.obj.get('time', DEFAULT_TIME)
         try:
             prompt_line, total_cost, model_name = trace(

pdd/unfinished_prompt.py

@@ -1,4 +1,5 @@
-from typing import Tuple
+from typing import Tuple, Optional
+import ast
 from pydantic import BaseModel, Field
 from rich import print as rprint
 from .load_prompt_template import load_prompt_template
@@ -14,6 +15,7 @@ def unfinished_prompt(
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0,
     time: float = DEFAULT_TIME,
+    language: Optional[str] = None,
     verbose: bool = False
 ) -> Tuple[str, bool, float, str]:
     """
@@ -48,6 +50,40 @@ def unfinished_prompt(
         if not 0 <= temperature <= 1:
             raise ValueError("Temperature must be between 0 and 1")
 
+        # Step 0: Fast syntactic completeness check for Python tails
+        # Apply when language explicitly 'python' or when the text likely looks like Python.
+        def _looks_like_python(text: str) -> bool:
+            lowered = text.strip().lower()
+            py_signals = (
+                "def ", "class ", "import ", "from ",
+            )
+            if any(sig in lowered for sig in py_signals):
+                return True
+            # Heuristic: has 'return ' without JS/TS markers
+            if "return " in lowered and not any(tok in lowered for tok in ("function", "=>", ";", "{", "}")):
+                return True
+            # Heuristic: colon-introduced blocks and indentation
+            if ":\n" in text or "\n    " in text:
+                return True
+            return False
+
+        should_try_python_parse = (language or "").lower() == "python" or _looks_like_python(prompt_text)
+        if should_try_python_parse:
+            try:
+                ast.parse(prompt_text)
+                reasoning = "Syntactic Python check passed (ast.parse succeeded); treating as finished."
+                if verbose:
+                    rprint("[green]" + reasoning + "[/green]")
+                return (
+                    reasoning,
+                    True,
+                    0.0,
+                    "syntactic_check"
+                )
+            except SyntaxError:
+                # Fall through to LLM-based judgment
+                pass
+
         # Step 1: Load the prompt template
         if verbose:
            rprint("[blue]Loading prompt template...[/blue]")
@@ -58,6 +94,9 @@ def unfinished_prompt(
 
         # Step 2: Prepare input and invoke LLM
         input_json = {"PROMPT_TEXT": prompt_text}
+        # Optionally pass a language hint to the prompt
+        if language:
+            input_json["LANGUAGE"] = language
         
         if verbose:
             rprint("[blue]Invoking LLM model...[/blue]")
@@ -116,4 +155,4 @@ if __name__ == "__main__":
         rprint(f"Cost: ${cost:.6f}")
         rprint(f"Model: {model}")
     except Exception as e:
-        rprint("[red]Error in example:[/red]", str(e))
+        rprint("[red]Error in example:[/red]", str(e))

{pdd_cli-0.0.49.dist-info → pdd_cli-0.0.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdd-cli
-Version: 0.0.49
+Version: 0.0.50
 Summary: PDD (Prompt-Driven Development) Command Line Interface
 Author: Greg Tanaka
 Author-email: glt@alumni.caltech.edu
@@ -45,9 +45,11 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: z3-solver; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
 Dynamic: license-file
 
-.. image:: https://img.shields.io/badge/pdd--cli-v0.0.49-blue
+.. image:: https://img.shields.io/badge/pdd--cli-v0.0.50-blue
    :alt: PDD-CLI Version
 
 .. image:: https://img.shields.io/badge/Discord-join%20chat-7289DA.svg?logo=discord&logoColor=white&link=https://discord.gg/Yp4RTh8bG7
@@ -124,7 +126,7 @@ After installation, verify:
 
    pdd --version
 
-You'll see the current PDD version (e.g., 0.0.49).
+You'll see the current PDD version (e.g., 0.0.50).
 
 Getting Started with Examples
 -----------------------------