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

pdd/templates/generic/generate_prompt.prompt

@@ -0,0 +1,174 @@
+---
+name: generic/generate_prompt
+description: Generate a module prompt (.prompt) for any stack (backend, frontend, CLI, jobs) using project docs and context
+version: 1.0.0
+tags: [template, prompt, generic]
+language: prompt
+output: prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt
+variables:
+  MODULE:
+    required: true
+    type: string
+    description: Module/component basename to generate a prompt for.
+    examples: [orders, auth, users]
+  LANG_OR_FRAMEWORK:
+    required: false
+    type: string
+    description: Target language or framework suffix used in prompt naming (matches your stack conventions).
+    examples: [Python, TypeScriptReact, Go, Java, Ruby]
+    default: Python
+  LAYER:
+    required: false
+    type: string
+    description: System layer or interface type for context.
+    examples: [backend, frontend, api, graphql, cli, job, message, config, module, component, page]
+  PRD_FILE:
+    required: false
+    type: path
+    description: Product requirements document providing overall context.
+    example_paths: [PRD.md, docs/product/prd.md]
+  API_DOC_FILE:
+    required: false
+    type: path
+    description: API documentation describing endpoints and conventions.
+    example_paths: [docs/api-documentation.md, docs/api.md]
+  DB_SCHEMA_FILE:
+    required: false
+    type: path
+    description: Database schema or ERD for backend data models.
+    example_paths: [context/database-schema.md, docs/db/schema.md]
+  BACKEND_FILES_CSV:
+    required: false
+    type: path
+    description: CSV listing backend Python files/modules (for context/reference).
+    example_paths: [prompts/backend/python_architecture.csv]
+  IO_DEPENDENCIES_CSV:
+    required: false
+    type: path
+    description: CSV of function inputs/outputs and dependencies for backend modules.
+    example_paths: [prompts/backend/io_dependencies.csv]
+  ARCHITECTURE_FILE:
+    required: true
+    type: path
+    description: Architecture JSON (from architecture/architecture_json) to drive module scope, dependencies, and interface.
+    example_paths: [architecture.json]
+  TECH_STACK_FILE:
+    required: false
+    type: path
+    description: Tech stack overview (languages, frameworks, infrastructure, tools) for shaping conventions.
+    example_paths: [docs/tech_stack.md, docs/architecture/stack.md]
+  CODE_GENERATOR_PROMPT:
+    required: false
+    type: path
+    description: Reference code generator prompt to mirror style and expectations.
+    example_paths: [prompts/code_generator_python.prompt, prompts/code_generator_main_python.prompt]
+  EXISTING_PROMPTS:
+    required: false
+    type: list
+    description: Existing prompt files to use as reference (comma/newline-separated).
+    example_paths: [prompts/orders_python.prompt, prompts/auth_python.prompt]
+  DEP_EXAMPLE_EXT:
+    required: false
+    type: string
+    description: File extension for dependency examples under context/ (for non-Python stacks).
+    examples: [py, ts, tsx, go, java]
+    default: py
+usage:
+  generate:
+    - name: Minimal (architecture only)
+      command: pdd generate --template generic/generate_prompt -e MODULE=orders -e LANG_OR_FRAMEWORK=Python -e ARCHITECTURE_FILE=architecture.json --output 'prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt'
+    - name: With project docs
+      command: pdd generate --template generic/generate_prompt -e MODULE=orders -e LANG_OR_FRAMEWORK=Python -e ARCHITECTURE_FILE=architecture.json -e PRD_FILE=docs/PRD.md -e API_DOC_FILE=docs/api-documentation.md -e DB_SCHEMA_FILE=context/database-schema.md --output 'prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt'
+    - name: With CSVs and references (backend/Python)
+      command: pdd generate --template generic/generate_prompt -e MODULE=orders -e LANG_OR_FRAMEWORK=Python -e ARCHITECTURE_FILE=architecture.json -e PRD_FILE=docs/PRD.md -e API_DOC_FILE=docs/api-documentation.md -e DB_SCHEMA_FILE=context/database-schema.md -e BACKEND_FILES_CSV=prompts/backend/python_architecture.csv -e IO_DEPENDENCIES_CSV=prompts/backend/io_dependencies.csv -e CODE_GENERATOR_PROMPT=prompts/code_generator_python.prompt --output 'prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt'
+    - name: Frontend (TypeScriptReact) variant
+      command: pdd generate --template generic/generate_prompt -e MODULE=profile_page -e LANG_OR_FRAMEWORK=TypeScriptReact -e LAYER=frontend -e ARCHITECTURE_FILE=architecture.json -e PRD_FILE=docs/PRD.md --output 'prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt'
+    - name: From architecture.json
+      command: pdd generate --template generic/generate_prompt -e MODULE=orders_api -e LANG_OR_FRAMEWORK=Python -e LAYER=api -e ARCHITECTURE_FILE=architecture.json --output 'prompts/${MODULE}_${LANG_OR_FRAMEWORK}.prompt'
+
+discover:
+  enabled: false
+  max_per_pattern: 5
+  max_total: 10
+---
+
+% You are an expert prompt writer and software architect for PDD. Your goal is to write a high-quality prompt that will generate the code for the ${MODULE} module/component. The prompt you create will be used to produce a detailed implementation specification in a file named ${MODULE}_${LANG_OR_FRAMEWORK}.prompt, suitable for the specified stack and layer.
+
+IMPORTANT: Your reply MUST begin with `<prompt>` on the very first line and end with `</prompt>` on the final line. Do not include any text, whitespace, or code fences outside this block.
+
+% Project context (architecture required, others optional):
+<prd><include>${PRD_FILE}</include></prd>
+<api><include>${API_DOC_FILE}</include></api>
+<database><include>${DB_SCHEMA_FILE}</include></database>
+<backend_files_csv><include>${BACKEND_FILES_CSV}</include></backend_files_csv>
+<io_dependencies_csv><include>${IO_DEPENDENCIES_CSV}</include></io_dependencies_csv>
+<architecture><include>${ARCHITECTURE_FILE}</include></architecture>
+<tech_stack><include>${TECH_STACK_FILE}</include></tech_stack>
+<generate_code_cli_example><include>${CODE_GENERATOR_PROMPT}</include></generate_code_cli_example>
+
+% Existing prompt references (optional):
+<existing_backend_prompts><include-many>${EXISTING_PROMPTS}</include-many></existing_backend_prompts>
+
+% Do the following:
+- Explain concisely what you are going to do (create a prompt for the ${MODULE} module/component for the specified layer and stack).
+- Analyze any difficulties this prompt might encounter for ${MODULE} (e.g., data modeling, API or UI contracts, transactions, idempotency, auth, state management, error handling) and briefly state mitigation strategies tailored to the given LAYER and LANG_OR_FRAMEWORK.
+- Use the ARCHITECTURE_FILE to identify the item that corresponds to this prompt by matching `filename` to `${MODULE}_${LANG_OR_FRAMEWORK}.prompt` (or best match by basename and layer). Use that item’s `reason`, `description`, `dependencies`, `interface`, and `tags` to shape the sections below.
+- Then create the prompt content for ${MODULE} inside XML tags named prompt, ensuring conventions fit the stack and layer.
+- Ensure the final response consists solely of the `<prompt>...</prompt>` block; nothing else (including whitespace) may appear before `<prompt>` or after `</prompt>`.
+
+% The prompt you generate must follow this structure:
+1) First paragraph: describe the role and responsibility of the ${MODULE} module/component within the system (consider the LAYER if provided).
+2) A "Requirements" section with numbered points covering functionality, contracts, error handling, validation, logging, performance, and security.
+3) A "Dependencies" section using XML include tags for each dependency (see format below).
+4) An "Instructions" section with precise implementation guidance (clarify inputs/outputs, function/class responsibilities, edge cases, and testing notes).
+5) A clear "Deliverable" section describing the expected code artifacts and entry points.
+
+% Dependencies format and conventions:
+- Represent each dependency using an XML tag with the dependency name, and put the file path inside an <include> tag, e.g.:
+  <orders_service>
+    <include>context/orders_service_example.${DEP_EXAMPLE_EXT}</include>
+  </orders_service>
+- Prefer real example files available in the provided context (use <include-many> when listing multiple). If examples are not provided, assume dependency examples live under context/ using the pattern context/[dependency_name]_example.${DEP_EXAMPLE_EXT}.
+- Include all necessary dependencies for the module/component (based on the provided context and references).
+- The ARCHITECTURE_FILE lists `dependencies` referencing other prompt filenames. Convert each dependency prompt filename into a sensible dependency name (strip language suffix and `_prompt`), and map to context files with the `${DEP_EXAMPLE_EXT}` extension if present; otherwise, list the prompt filename explicitly in a "Prompt Dependencies" subsection.
+
+% Architecture awareness (ARCHITECTURE_FILE is required):
+- Align the "Requirements" and "Instructions" with the selected item’s `interface.type` (e.g., page, component, module, api, graphql, cli, job, message, config).
+- For `api`, outline endpoints (method, path, auth) consistent with the architecture description; for `page`/`component`, describe route/props/data sources; for `job`, include trigger and retry policy; for `config`, list keys and sources.
+
+% Style and quality requirements:
+- The generated prompt must be detailed enough to yield production-ready code.
+- Match the style and patterns of existing *_${LANG_OR_FRAMEWORK}.prompt files when present.
+- Do not invent technologies or files; rely on the included context. If assumptions are necessary, state them explicitly and conservatively.
+
+% Output contract:
+- Start the output with `<prompt>` on its own line and end with `</prompt>` on its own line.
+- Do not emit any characters (including whitespace, markdown fences, or commentary) outside the `<prompt>...</prompt>` block.
+- Within the tags, include the sections described above as plain text.
+- OUTPUT FORMAT (authoritative – copy/paste and replace the bracketed placeholders, keeping every literal token):
+  ```text
+  <prompt>
+  {ROLE_PARAGRAPH}
+  Requirements
+  1. {REQ_ITEM_1}
+  2. {REQ_ITEM_2}
+  Dependencies
+  <{DEPENDENCY_TAG_1}>
+    <include>{DEPENDENCY_INCLUDE_1}</include>
+  </{DEPENDENCY_TAG_1}>
+  {OPTIONAL_ADDITIONAL_DEPENDENCY_TAGS}
+  Prompt Dependencies:
+  {PROMPT_DEPENDENCIES_SECTION}
+  Instructions
+  - {INSTRUCTION_1}
+  - {INSTRUCTION_2}
+  Deliverable
+  - {DELIVERABLE_1}
+  - {DELIVERABLE_2}
+  Implementation assumptions (explicit)
+  - {ASSUMPTION_1}
+  - {ASSUMPTION_2}
+  Please produce production-ready prompt content that will generate the module consistent with the above.
+  </prompt>
+  ```
+  Replace each `{PLACEHOLDER}` with concrete content while preserving the surrounding structure and literal `<prompt>` / `<include>` tags.

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,88 @@ 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)
+                    ctx.obj['core_dump_files'] = 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)
+
+            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,28 +110,70 @@ 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
+    # 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}")
     return input_files, output_files