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

pdd/trace.py

@@ -1,14 +1,48 @@
-from typing import Tuple, Optional
+from typing import Tuple, Optional, List
 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
 from . import DEFAULT_TIME, DEFAULT_STRENGTH
 console = Console()
 
+
+def _normalize_text(value: str) -> str:
+    if value is None:
+        return ""
+    value = value.replace("\u201c", '"').replace("\u201d", '"')
+    value = value.replace("\u2018", "'").replace("\u2019", "'")
+    value = value.replace("\u00A0", " ")
+    value = re.sub(r"\s+", " ", value.strip())
+    return value
+
+
+def _fallback_prompt_line(prompt_lines: List[str], code_str: str) -> int:
+    """Best-effort deterministic fallback to select a prompt line."""
+    normalized_code = _normalize_text(code_str).casefold()
+    tokens = [tok for tok in re.split(r"\W+", normalized_code) if len(tok) >= 3]
+
+    token_best_idx: Optional[int] = None
+    token_best_hits = 0
+    if tokens:
+        for i, line in enumerate(prompt_lines, 1):
+            normalized_line = _normalize_text(line).casefold()
+            hits = sum(1 for tok in tokens if tok in normalized_line)
+            if hits > token_best_hits:
+                token_best_hits = hits
+                token_best_idx = i
+    if token_best_idx is not None and token_best_hits > 0:
+        return token_best_idx
+
+    for i, line in enumerate(prompt_lines, 1):
+        if _normalize_text(line):
+            return i
+    return 1
+
 class PromptLineOutput(BaseModel):
     prompt_line: str = Field(description="The line from the prompt file that matches the code")
 
@@ -102,38 +136,160 @@ 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
+        # 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 7c: Deterministic fallback when LLM output cannot be matched reliably
+        fallback_used = False
+        if best_match is None:
+            best_match = _fallback_prompt_line(prompt_lines, code_str)
+            fallback_used = True
 
         # Step 8: Return results
         if verbose:
             console.print(f"[green]Found matching line: {best_match}[/green]")
             console.print(f"[green]Total cost: ${total_cost:.6f}[/green]")
             console.print(f"[green]Model used: {model_name}[/green]")
+            if fallback_used:
+                console.print("[yellow]Fallback matching heuristic was used.[/yellow]")
 
         return best_match, total_cost, model_name
 
     except Exception as e:
         console.print(f"[bold red]Error in trace function: {str(e)}[/bold red]")
-        return None, 0.0, ""
+        try:
+            fallback_line = _fallback_prompt_line(prompt_file.splitlines(), code_file.splitlines()[code_line - 1] if 0 < code_line <= len(code_file.splitlines()) else "")
+        except Exception:
+            fallback_line = 1
+        return fallback_line, 0.0, "fallback"

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__)
 
@@ -39,7 +39,8 @@ def trace_main(ctx: click.Context, prompt_file: str, code_file: str, code_line:
             force=ctx.obj.get('force', False),
             quiet=quiet,
             command="trace",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
         logger.debug("File paths constructed successfully")
 
@@ -50,7 +51,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/track_cost.py

@@ -14,53 +14,94 @@ def track_cost(func):
             return func(*args, **kwargs)
 
         start_time = datetime.now()
-        try:
-            result = func(*args, **kwargs)
-        except Exception as e:
-            raise e
-        end_time = datetime.now()
+        result = None
+        exception_raised = None
 
         try:
-            if ctx.obj and hasattr(ctx.obj, 'get'):
-                output_cost_path = ctx.obj.get('output_cost') or os.getenv('PDD_OUTPUT_COST_PATH')
-            else:
-                output_cost_path = os.getenv('PDD_OUTPUT_COST_PATH')
-            
-            if not output_cost_path:
-                return result
-
-            command_name = ctx.command.name
-
-            cost, model_name = extract_cost_and_model(result)
-
-            input_files, output_files = collect_files(args, kwargs)
-
-            timestamp = start_time.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3]
-
-            row = {
-                'timestamp': timestamp,
-                'model': model_name,
-                'command': command_name,
-                'cost': cost,
-                'input_files': ';'.join(input_files),
-                'output_files': ';'.join(output_files),
-            }
-
-            file_exists = os.path.isfile(output_cost_path)
-            fieldnames = ['timestamp', 'model', 'command', 'cost', 'input_files', 'output_files']
-
-            with open(output_cost_path, 'a', newline='', encoding='utf-8') as csvfile:
-                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-                if not file_exists:
-                    writer.writeheader()
-                writer.writerow(row)
-
-            print(f"Debug: Writing row to CSV: {row}")
-            print(f"Debug: Input files: {input_files}")
-            print(f"Debug: Output files: {output_files}")
+            # Record the invoked subcommand name on the shared ctx.obj so
+            # the CLI result callback can display proper names instead of
+            # falling back to "Unknown Command X".
+            try:
+                # Avoid interfering with pytest-based CLI tests which expect
+                # Click's default behavior (yielding "Unknown Command X").
+                if not os.environ.get('PYTEST_CURRENT_TEST'):
+                    if ctx.obj is not None:
+                        invoked = ctx.obj.get('invoked_subcommands') or []
+                        # Use the current command name if available
+                        cmd_name = ctx.command.name if ctx.command else None
+                        if cmd_name:
+                            invoked.append(cmd_name)
+                            ctx.obj['invoked_subcommands'] = invoked
+            except Exception:
+                # Non-fatal: if we cannot record, proceed normally
+                pass
 
+            result = func(*args, **kwargs)
         except Exception as e:
-            rprint(f"[red]Error tracking cost: {e}[/red]")
+            exception_raised = e
+        finally:
+            end_time = datetime.now()
+
+            try:
+                # Always collect files for core dump, even if output_cost is not set
+                input_files, output_files = collect_files(args, kwargs)
+
+                # Store collected files in context for core dump (even if output_cost not set)
+                if ctx.obj is not None and ctx.obj.get('core_dump'):
+                    files_set = ctx.obj.get('core_dump_files', set())
+                    for f in input_files + output_files:
+                        if isinstance(f, str) and f:
+                            # Convert to absolute path for reliable access later
+                            abs_path = os.path.abspath(f)
+                            # Add the file if it exists OR if it looks like a file path
+                            # (it might have been created/deleted during command execution)
+                            if os.path.exists(abs_path) or '.' in os.path.basename(f):
+                                files_set.add(abs_path)
+                                print(f"Debug: Added to core_dump_files: {abs_path} (exists: {os.path.exists(abs_path)})")
+                    ctx.obj['core_dump_files'] = files_set
+                    print(f"Debug: Total files in core_dump_files: {len(files_set)}")
+
+                # Check if we need to write cost tracking (only on success)
+                if exception_raised is None:
+                    if ctx.obj and hasattr(ctx.obj, 'get'):
+                        output_cost_path = ctx.obj.get('output_cost') or os.getenv('PDD_OUTPUT_COST_PATH')
+                    else:
+                        output_cost_path = os.getenv('PDD_OUTPUT_COST_PATH')
+
+                    if output_cost_path:
+                        command_name = ctx.command.name
+                        cost, model_name = extract_cost_and_model(result)
+
+                        timestamp = start_time.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3]
+
+                        row = {
+                            'timestamp': timestamp,
+                            'model': model_name,
+                            'command': command_name,
+                            'cost': cost,
+                            'input_files': ';'.join(input_files),
+                            'output_files': ';'.join(output_files),
+                        }
+
+                        file_exists = os.path.isfile(output_cost_path)
+                        fieldnames = ['timestamp', 'model', 'command', 'cost', 'input_files', 'output_files']
+
+                        with open(output_cost_path, 'a', newline='', encoding='utf-8') as csvfile:
+                            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                            if not file_exists:
+                                writer.writeheader()
+                            writer.writerow(row)
+
+                        print(f"Debug: Writing row to CSV: {row}")
+                        print(f"Debug: Input files: {input_files}")
+                        print(f"Debug: Output files: {output_files}")
+
+            except Exception as e:
+                rprint(f"[red]Error tracking cost: {e}[/red]")
+
+        # Re-raise the exception if one occurred
+        if exception_raised is not None:
+            raise exception_raised
 
         return result
 
@@ -75,27 +116,76 @@ def collect_files(args, kwargs):
     input_files = []
     output_files = []
 
-    # Collect from args
-    for arg in args:
-        if isinstance(arg, str):
-            input_files.append(arg)
-        elif isinstance(arg, list):
-            input_files.extend([f for f in arg if isinstance(f, str)])
-
-    # Collect from kwargs
+    print(f"Debug: collect_files called")
+    print(f"Debug: args = {args}")
+    print(f"Debug: kwargs keys = {list(kwargs.keys())}")
+    print(f"Debug: kwargs = {kwargs}")
+
+    # Known input parameter names that typically contain file paths
+    input_param_names = {
+        'prompt_file', 'prompt', 'input', 'input_file', 'source', 'source_file',
+        'file', 'path', 'original_prompt_file_path', 'files', 'core_file',
+        'code_file', 'unit_test_file', 'error_file', 'test_file', 'example_file'
+    }
+
+    # Known output parameter names (anything with 'output' in the name)
+    output_param_names = {
+        'output', 'output_file', 'output_path', 'destination', 'dest', 'target',
+        'output_test', 'output_code', 'output_results'
+    }
+
+    # Helper to check if something looks like a file path
+    def looks_like_file(path_str):
+        """Check if string looks like a file path."""
+        if not path_str or not isinstance(path_str, str):
+            return False
+        # Has file extension or exists
+        return '.' in os.path.basename(path_str) or os.path.isfile(path_str)
+
+    # Collect from kwargs (most reliable since Click uses named parameters)
     for k, v in kwargs.items():
-        if k == 'output_cost':
+        if k in ('ctx', 'context', 'output_cost'):
             continue
-        if isinstance(v, str):
-            if k.startswith('output'):
-                output_files.append(v)
-            else:
-                input_files.append(v)
+
+        # Check if this is a known parameter name
+        is_input_param = k in input_param_names or 'file' in k.lower() or 'prompt' in k.lower()
+        is_output_param = k in output_param_names or 'output' in k.lower()
+
+        if isinstance(v, str) and v:
+            # For known parameter names, trust that they represent file paths
+            # For unknown parameters, check if it looks like a file
+            if is_input_param or is_output_param or looks_like_file(v):
+                if is_output_param:
+                    output_files.append(v)
+                elif is_input_param:
+                    input_files.append(v)
+                else:
+                    # Unknown parameter but looks like a file, treat as input
+                    input_files.append(v)
         elif isinstance(v, list):
-            if k.startswith('output'):
-                output_files.extend([f for f in v if isinstance(f, str)])
-            else:
-                input_files.extend([f for f in v if isinstance(f, str)])
+            for item in v:
+                if isinstance(item, str) and item:
+                    # Same logic for list items
+                    if is_input_param or is_output_param or looks_like_file(item):
+                        if is_output_param:
+                            output_files.append(item)
+                        elif is_input_param:
+                            input_files.append(item)
+                        else:
+                            input_files.append(item)
+
+    # Collect from positional args (skip first arg which is usually Click context)
+    for i, arg in enumerate(args):
+        # Skip first argument if it looks like a Click context
+        if i == 0 and hasattr(arg, 'obj'):
+            continue
+
+        if isinstance(arg, str) and arg and looks_like_file(arg):
+            input_files.append(arg)
+        elif isinstance(arg, list):
+            for item in arg:
+                if isinstance(item, str) and item and looks_like_file(item):
+                    input_files.append(item)
 
     print(f"Debug: Collected input files: {input_files}")
     print(f"Debug: Collected output files: {output_files}")

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]")
@@ -79,10 +118,17 @@ def unfinished_prompt(
         )
 
         # Step 3: Extract and return results
-        result: PromptAnalysis = response['result']
+        result = response['result']
         total_cost = response['cost']
         model_name = response['model_name']
 
+        # Defensive type checking: ensure we got a PromptAnalysis, not a raw string
+        if not isinstance(result, PromptAnalysis):
+            raise TypeError(
+                f"Expected PromptAnalysis from llm_invoke, got {type(result).__name__}. "
+                f"This typically indicates JSON parsing failed. Value: {repr(result)[:200]}"
+            )
+
         if verbose:
            rprint("[green]Analysis complete![/green]")
            rprint(f"Reasoning: {result.reasoning}")
@@ -116,4 +162,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))