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

pdd/construct_paths.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import sys
 import os
 from pathlib import Path
-from typing import Dict, Tuple, Any, Optional, List
+from typing import Dict, Tuple, Any, Optional, List, Callable
 import fnmatch
 import logging
 
@@ -56,6 +56,23 @@ def _load_pddrc_config(pddrc_path: Path) -> Dict[str, Any]:
     except Exception as e:
         raise ValueError(f"Error loading .pddrc: {e}")
 
+def list_available_contexts(start_path: Optional[Path] = None) -> list[str]:
+    """Return sorted context names from the nearest .pddrc.
+
+    - Searches upward from `start_path` (or CWD) for a `.pddrc` file.
+    - If found, loads and validates it, then returns sorted context names.
+    - If no `.pddrc` exists, returns ["default"].
+    - Propagates ValueError for malformed `.pddrc` to allow callers to render
+      helpful errors.
+    """
+    pddrc = _find_pddrc_file(start_path)
+    if not pddrc:
+        return ["default"]
+    config = _load_pddrc_config(pddrc)
+    contexts = config.get("contexts", {})
+    names = sorted(contexts.keys()) if isinstance(contexts, dict) else []
+    return names or ["default"]
+
 def _detect_context(current_dir: Path, config: Dict[str, Any], context_override: Optional[str] = None) -> Optional[str]:
     """Detect the appropriate context based on current directory path."""
     if context_override:
@@ -108,8 +125,9 @@ def _resolve_config_hierarchy(
     # Configuration keys to resolve
     config_keys = {
         'generate_output_path': 'PDD_GENERATE_OUTPUT_PATH',
-        'test_output_path': 'PDD_TEST_OUTPUT_PATH', 
+        'test_output_path': 'PDD_TEST_OUTPUT_PATH',
         'example_output_path': 'PDD_EXAMPLE_OUTPUT_PATH',
+        'prompts_dir': 'PDD_PROMPTS_DIR',
         'default_language': 'PDD_DEFAULT_LANGUAGE',
         'target_coverage': 'PDD_TEST_COVERAGE_TARGET',
         'strength': None,
@@ -176,52 +194,41 @@ def _candidate_prompt_path(input_files: Dict[str, Path]) -> Path | None:
     for p in input_files.values():
         if p.suffix == ".prompt":
             return p
+    
+    # Final fallback: Return the first file path available (e.g. for pdd update <code_file>)
+    if input_files:
+        return next(iter(input_files.values()))
+        
     return None
 
 
 # New helper function to check if a language is known
 def _is_known_language(language_name: str) -> bool:
-    """Checks if a language name is present in the language_format.csv."""
+    """Return True if the language is recognized.
+
+    Prefer CSV in PDD_PATH if available; otherwise fall back to a built-in set
+    so basename/language inference does not fail when PDD_PATH is unset.
+    """
+    language_name_lower = (language_name or "").lower()
+    if not language_name_lower:
+        return False
+
+    builtin_languages = {
+        'python', 'javascript', 'typescript', 'java', 'cpp', 'c', 'go', 'ruby', 'rust',
+        'kotlin', 'swift', 'csharp', 'php', 'scala', 'r', 'lua', 'perl', 'bash', 'shell',
+        'powershell', 'sql', 'prompt', 'html', 'css', 'makefile',
+        # Common data and config formats for architecture prompts and configs
+        'json', 'jsonl', 'yaml', 'yml', 'toml', 'ini'
+    }
+
     pdd_path_str = os.getenv('PDD_PATH')
     if not pdd_path_str:
-        # Consistent with get_extension, raise ValueError if PDD_PATH is not set.
-        # Or, for an internal helper, we might decide to log and return False,
-        # but raising an error for missing config is generally safer.
-        # However, _determine_language (the caller) already raises ValueError
-        # if language cannot be found, so this path might not be strictly necessary
-        # if we assume PDD_PATH is validated earlier or by other get_extension/get_language calls.
-        # For robustness here, let's keep a check but perhaps make it less severe if called internally.
-        # For now, align with how get_extension might handle it.
-        # console.print("[error]PDD_PATH environment variable is not set. Cannot validate language.", style="error")
-        # return False # Or raise error
-        # Given this is internal and other functions (get_extension) already depend on PDD_PATH,
-        # we can assume if those ran, PDD_PATH is set. If not, they'd fail first.
-        # So, we can simplify or rely on that pre-condition.
-        # Let's assume PDD_PATH will be set if other language functions are working.
-        # If it's critical, an explicit check and raise ValueError is better.
-        # For now, let's proceed assuming PDD_PATH is available if this point is reached.
-        pass # Assuming PDD_PATH is checked by get_extension/get_language if they are called
-
-    # If PDD_PATH is not set, this will likely fail earlier if get_extension/get_language are used.
-    # If we want this helper to be fully independent, it needs robust PDD_PATH handling.
-    # Let's assume for now, PDD_PATH is available if this point is reached through normal flow.
-    
-    # Re-evaluate: PDD_PATH is critical for this function. Let's keep the check.
-    if not pdd_path_str:
-        # This helper might be called before get_extension in some logic paths
-        # if _determine_language prioritizes suffix checking first.
-        # So, it needs its own PDD_PATH check.
-        # Raise ValueError to be consistent with get_extension's behavior.
-        raise ValueError("PDD_PATH environment variable is not set. Cannot validate language.")
+        return language_name_lower in builtin_languages
 
     csv_file_path = Path(pdd_path_str) / 'data' / 'language_format.csv'
-    
     if not csv_file_path.is_file():
-        # Raise FileNotFoundError if CSV is missing, consistent with get_extension
-        raise FileNotFoundError(f"The language format CSV file does not exist: {csv_file_path}")
-            
-    language_name_lower = language_name.lower()
-    
+        return language_name_lower in builtin_languages
+
     try:
         with open(csv_file_path, mode='r', encoding='utf-8', newline='') as csvfile:
             reader = csv.DictReader(csvfile)
@@ -229,10 +236,10 @@ def _is_known_language(language_name: str) -> bool:
                 if row.get('language', '').lower() == language_name_lower:
                     return True
     except csv.Error as e:
-        # Log and return False or raise a custom error
         console.print(f"[error]CSV Error reading {csv_file_path}: {e}", style="error")
-        return False # Indicates language could not be confirmed due to CSV issue
-    return False
+        return language_name_lower in builtin_languages
+
+    return language_name_lower in builtin_languages
 
 
 def _strip_language_suffix(path_like: os.PathLike[str]) -> str:
@@ -264,6 +271,24 @@ def _extract_basename(
     """
     Deduce the project basename according to the rules explained in *Step A*.
     """
+    # Handle 'fix' command specifically to create a unique basename per test file
+    if command == "fix":
+        prompt_path = _candidate_prompt_path(input_file_paths)
+        if not prompt_path:
+            raise ValueError("Could not determine prompt file for 'fix' command.")
+        
+        prompt_basename = _strip_language_suffix(prompt_path)
+        
+        unit_test_path = input_file_paths.get("unit_test_file")
+        if not unit_test_path:
+            # Fallback to just the prompt basename if no unit test file is provided
+            # This might happen in some edge cases, but 'fix' command structure requires it
+            return prompt_basename
+
+        # Use the stem of the unit test file to make the basename unique
+        test_basename = Path(unit_test_path).stem
+        return f"{prompt_basename}_{test_basename}"
+        
     # Handle conflicts first due to its unique structure
     if command == "conflicts":
         key1 = "prompt1"
@@ -331,14 +356,48 @@ def _determine_language(
         ext = path_obj.suffix
         # Prioritize non-prompt code files
         if ext and ext != ".prompt":
-            language = get_language(ext)
-            if language:
-                return language.lower()
+            try:
+                language = get_language(ext)
+                if language:
+                    return language.lower()
+            except ValueError:
+                # Fallback: load language CSV file directly when PDD_PATH is not set
+                try:
+                    import csv
+                    import os
+                    # Try to find the CSV file relative to this script
+                    script_dir = os.path.dirname(os.path.abspath(__file__))
+                    csv_path = os.path.join(script_dir, 'data', 'language_format.csv')
+                    if os.path.exists(csv_path):
+                        with open(csv_path, 'r') as csvfile:
+                            reader = csv.DictReader(csvfile)
+                            for row in reader:
+                                if row['extension'].lower() == ext.lower():
+                                    return row['language'].lower()
+                except (FileNotFoundError, csv.Error):
+                    pass
         # Handle files without extension like Makefile
         elif not ext and path_obj.is_file(): # Check it's actually a file
-            language = get_language(path_obj.name) # Check name (e.g., 'Makefile')
-            if language:
-                return language.lower()
+            try:
+                language = get_language(path_obj.name) # Check name (e.g., 'Makefile')
+                if language:
+                    return language.lower()
+            except ValueError:
+                # Fallback: load language CSV file directly for files without extension
+                try:
+                    import csv
+                    import os
+                    script_dir = os.path.dirname(os.path.abspath(__file__))
+                    csv_path = os.path.join(script_dir, 'data', 'language_format.csv')
+                    if os.path.exists(csv_path):
+                        with open(csv_path, 'r') as csvfile:
+                            reader = csv.DictReader(csvfile)
+                            for row in reader:
+                                # Check if the filename matches (for files without extension)
+                                if not row['extension'] and path_obj.name.lower() == row['language'].lower():
+                                    return row['language'].lower()
+                except (FileNotFoundError, csv.Error):
+                    pass
 
     # 3 – parse from prompt filename suffix
     prompt_path = _candidate_prompt_path(input_file_paths)
@@ -354,7 +413,7 @@ def _determine_language(
 
     # 4 - Special handling for detect command - default to prompt for LLM prompts
     if command == "detect" and "change_file" in input_file_paths:
-        return "prompt"  # Default to prompt for detect command
+        return "prompt"
 
     # 5 - If no language determined, raise error
     raise ValueError("Could not determine language from input files or options.")
@@ -374,6 +433,8 @@ def construct_paths(
     command_options: Optional[Dict[str, Any]], # Allow None
     create_error_file: bool = True,  # Added parameter to control error file creation
     context_override: Optional[str] = None,  # Added parameter for context override
+    confirm_callback: Optional[Callable[[str, str], bool]] = None,  # Callback for interactive confirmation
+    path_resolution_mode: Optional[str] = None,  # "cwd" or "config_base" - if None, use command default
 ) -> Tuple[Dict[str, Any], Dict[str, str], Dict[str, str], str]:
     """
     High‑level orchestrator that loads inputs, determines basename/language,
@@ -390,8 +451,10 @@ def construct_paths(
 
     # ------------- Load .pddrc configuration -----------------
     pddrc_config = {}
+    pddrc_path: Optional[Path] = None
     context = None
     context_config = {}
+    original_context_config = {}  # Keep track of original context config for sync discovery
     
     try:
         # Find and load .pddrc file
@@ -405,6 +468,7 @@ def construct_paths(
             
             # Get context-specific configuration
             context_config = _get_context_config(pddrc_config, context)
+            original_context_config = context_config.copy()  # Store original before modifications
             
             if not quiet and context:
                 console.print(f"[info]Using .pddrc context:[/info] {context}")
@@ -448,13 +512,45 @@ def construct_paths(
                 language="python", # Dummy language
                 file_extension=".py", # Dummy extension
                 context_config=context_config,
+                config_base_dir=str(pddrc_path.parent) if pddrc_path else None,
+                path_resolution_mode="cwd",  # Sync resolves paths relative to CWD
             )
+
             # Infer base directories from a sample output path
             gen_path = Path(output_paths_str.get("generate_output_path", "src"))
-            resolved_config["prompts_dir"] = str(gen_path.parent.parent / "prompts")
-            resolved_config["code_dir"] = str(gen_path.parent)
+            
+            # First, check current working directory for prompt files matching the basename pattern
+            current_dir = Path.cwd()
+            prompt_pattern = f"{basename}_*.prompt"
+            if list(current_dir.glob(prompt_pattern)):
+                # Found prompt files in current working directory
+                resolved_config["prompts_dir"] = str(current_dir)
+                resolved_config["code_dir"] = str(current_dir)
+                if not quiet:
+                    console.print(f"[info]Found prompt files in current directory:[/info] {current_dir}")
+            else:
+                # Fall back to context-aware logic
+                # Use original_context_config to avoid checking augmented config with env vars
+                if original_context_config and any(key.endswith('_output_path') for key in original_context_config):
+                    # For configured contexts, use prompts_dir from config if provided,
+                    # otherwise default to "prompts" at the same level as output dirs
+                    resolved_config["prompts_dir"] = original_context_config.get("prompts_dir", "prompts")
+                    resolved_config["code_dir"] = str(gen_path.parent)
+                else:
+                    # For default contexts, maintain relative relationship 
+                    # e.g., if code goes to "pi.py", prompts should be at "prompts/" (siblings)
+                    resolved_config["prompts_dir"] = str(gen_path.parent / "prompts")
+                    resolved_config["code_dir"] = str(gen_path.parent)
+            
             resolved_config["tests_dir"] = str(Path(output_paths_str.get("test_output_path", "tests")).parent)
-            resolved_config["examples_dir"] = str(Path(output_paths_str.get("example_output_path", "examples")).parent)
+            # example_output_path can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
+            # If it ends with / or has no file extension, treat as directory; otherwise use parent
+            example_path_str = output_paths_str.get("example_output_path", "examples")
+            example_path = Path(example_path_str)
+            if example_path_str.endswith('/') or '.' not in example_path.name:
+                resolved_config["examples_dir"] = example_path_str.rstrip('/')
+            else:
+                resolved_config["examples_dir"] = str(example_path.parent)
 
         except Exception as e:
             console.print(f"[error]Failed to determine initial paths for sync: {e}", style="error")
@@ -473,11 +569,15 @@ def construct_paths(
     for key, path_str in input_file_paths.items():
         try:
             path = Path(path_str).expanduser()
-            # Resolve non-error files strictly first
+            # Resolve non-error files strictly first, but be more lenient for sync command
             if key != "error_file":
-                 # Let FileNotFoundError propagate naturally if path doesn't exist
-                 resolved_path = path.resolve(strict=True)
-                 input_paths[key] = resolved_path
+                 # For sync command, be more tolerant of non-existent files since we're just determining paths
+                 if command == "sync":
+                     input_paths[key] = path.resolve()
+                 else:
+                     # Let FileNotFoundError propagate naturally if path doesn't exist
+                     resolved_path = path.resolve(strict=True)
+                     input_paths[key] = resolved_path
             else:
                  # Resolve error file non-strictly, existence checked later
                  input_paths[key] = path.resolve()
@@ -507,9 +607,14 @@ def construct_paths(
 
         # Check existence again, especially for error_file which might have been created
         if not path.exists():
-             # This case should ideally be caught by resolve(strict=True) earlier for non-error files
-             # Raise standard FileNotFoundError
-             raise FileNotFoundError(f"{path}")
+             # For sync command, be more tolerant of non-existent files since we're just determining paths
+             if command == "sync":
+                 # Skip reading content for non-existent files in sync mode
+                 continue
+             else:
+                 # This case should ideally be caught by resolve(strict=True) earlier for non-error files
+                 # Raise standard FileNotFoundError
+                 raise FileNotFoundError(f"{path}")
 
         if path.is_file(): # Read only if it's a file
              try:
@@ -574,7 +679,25 @@ def construct_paths(
                 style="warning"
             )
 
-    file_extension = get_extension(language) # Pass determined language
+    
+    # Try to get extension from CSV; fallback to built-in mapping if PDD_PATH/CSV unavailable
+    try:
+        file_extension = get_extension(language)  # Pass determined language
+        if not file_extension and (language or '').lower() != 'prompt':
+            raise ValueError('empty extension')
+    except Exception:
+        builtin_ext_map = {
+            'python': '.py', 'javascript': '.js', 'typescript': '.ts', 'java': '.java',
+            'cpp': '.cpp', 'c': '.c', 'go': '.go', 'ruby': '.rb', 'rust': '.rs',
+            'kotlin': '.kt', 'swift': '.swift', 'csharp': '.cs', 'php': '.php',
+            'scala': '.scala', 'r': '.r', 'lua': '.lua', 'perl': '.pl', 'bash': '.sh',
+            'shell': '.sh', 'powershell': '.ps1', 'sql': '.sql', 'html': '.html', 'css': '.css',
+            'prompt': '.prompt', 'makefile': '',
+            # Common data/config formats
+            'json': '.json', 'jsonl': '.jsonl', 'yaml': '.yaml', 'yml': '.yml', 'toml': '.toml', 'ini': '.ini'
+        }
+        file_extension = builtin_ext_map.get(language.lower(), f".{language.lower()}" if language else '')
+
 
 
     # ------------- Step 3b: build output paths ---------------
@@ -584,10 +707,52 @@ def construct_paths(
         if k.startswith("output") and v is not None # Ensure value is not None
     }
 
+    # Determine input file directory for default output path generation
+    # Only apply for commands that generate/update files based on specific input files
+    # Commands like sync, generate, test, example have their own directory management
+    commands_using_input_dir = {'fix', 'crash', 'verify', 'split', 'change', 'update'}
+    input_file_dir: Optional[str] = None
+    input_file_dirs: Dict[str, Optional[str]] = {}
+    if input_paths and command in commands_using_input_dir:
+        try:
+            # For fix/crash/verify commands, use specific file directories for each output
+            if command in {'fix', 'crash', 'verify'}:
+                # Map output keys to their corresponding input file keys
+                input_key_map = {
+                    'fix': {'output_code': 'code_file', 'output_test': 'unit_test_file', 'output_results': 'code_file'},
+                    'crash': {'output': 'code_file', 'output_program': 'program_file'},
+                    'verify': {'output_code': 'code_file', 'output_program': 'verification_program', 'output_results': 'code_file'},
+                }
+
+                for output_key, input_key in input_key_map.get(command, {}).items():
+                    if input_key in input_paths:
+                        input_file_dirs[output_key] = str(input_paths[input_key].parent)
+
+                # Set default input_file_dir to code_file directory as fallback
+                if 'code_file' in input_paths:
+                    input_file_dir = str(input_paths['code_file'].parent)
+                else:
+                    first_input_path = next(iter(input_paths.values()))
+                    input_file_dir = str(first_input_path.parent)
+            else:
+                # For other commands, use first input path
+                first_input_path = next(iter(input_paths.values()))
+                input_file_dir = str(first_input_path.parent)
+        except (StopIteration, AttributeError):
+            # If no input paths or path doesn't have parent, use None (falls back to CWD)
+            pass
+
     try:
         # generate_output_paths might return Dict[str, str] or Dict[str, Path]
         # Let's assume it returns Dict[str, str] based on verification error,
         # and convert them to Path objects here.
+        # Determine path resolution mode:
+        # - If explicitly provided, use it
+        # - Otherwise: sync uses "cwd", other commands use "config_base"
+        effective_path_resolution_mode = path_resolution_mode
+        if effective_path_resolution_mode is None:
+            effective_path_resolution_mode = "cwd" if command == "sync" else "config_base"
+
         output_paths_str: Dict[str, str] = generate_output_paths(
             command=command,
             output_locations=output_location_opts,
@@ -595,7 +760,12 @@ def construct_paths(
             language=language,
             file_extension=file_extension,
             context_config=context_config,
+            input_file_dir=input_file_dir,
+            input_file_dirs=input_file_dirs,
+            config_base_dir=str(pddrc_path.parent) if pddrc_path else None,
+            path_resolution_mode=effective_path_resolution_mode,
         )
+
         # Convert to Path objects for internal use
         output_paths_resolved: Dict[str, Path] = {k: Path(v) for k, v in output_paths_str.items()}
 
@@ -604,36 +774,59 @@ def construct_paths(
          raise # Re-raise the ValueError
 
     # ------------- Step 4: overwrite confirmation ------------
-    # Check if any output *file* exists (operate on Path objects)
+    # Initialize existing_files before the conditional to avoid UnboundLocalError
     existing_files: Dict[str, Path] = {}
-    for k, p_obj in output_paths_resolved.items():
-        # p_obj = Path(p_val) # Conversion now happens earlier
-        if p_obj.is_file():
-            existing_files[k] = p_obj # Store the Path object
+
+    if command in ["test", "bug"] and not force:
+        # For test/bug commands without --force, create numbered files instead of overwriting
+        for key, path in output_paths_resolved.items():
+            if path.is_file():
+                base, ext = os.path.splitext(path)
+                i = 1
+                new_path = Path(f"{base}_{i}{ext}")
+                while new_path.exists():
+                    i += 1
+                    new_path = Path(f"{base}_{i}{ext}")
+                output_paths_resolved[key] = new_path
+    else:
+        # Check if any output *file* exists (operate on Path objects)
+        for k, p_obj in output_paths_resolved.items():
+            if p_obj.is_file():
+                existing_files[k] = p_obj # Store the Path object
 
     if existing_files and not force:
+        paths_list = "\n".join(f"  • {p.resolve()}" for p in existing_files.values())
         if not quiet:
             # Use the Path objects stored in existing_files for resolve()
             # Print without Rich tags for easier testing
-            paths_list = "\n".join(f"  • {p.resolve()}" for p in existing_files.values())
             console.print(
                 f"Warning: The following output files already exist and may be overwritten:\n{paths_list}",
                 style="warning"
             )
-        # Use click.confirm for user interaction
-        try:
-            if not click.confirm(
-                click.style("Overwrite existing files?", fg="yellow"), default=True, show_default=True
-            ):
-                click.secho("Operation cancelled.", fg="red", err=True)
-                sys.exit(1) # Exit if user chooses not to overwrite
-        except Exception as e: # Catch potential errors during confirm (like EOFError in non-interactive)
-            if 'EOF' in str(e) or 'end-of-file' in str(e).lower():
-                # Non-interactive environment, default to not overwriting
-                click.secho("Non-interactive environment detected. Use --force to overwrite existing files.", fg="yellow", err=True)
-            else:
-                click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
-            sys.exit(1)
+
+        # Use confirm_callback if provided (for TUI environments), otherwise use click.confirm
+        if confirm_callback is not None:
+            # Use the provided callback for confirmation (e.g., from Textual TUI)
+            confirm_message = f"The following files will be overwritten:\n{paths_list}\n\nOverwrite existing files?"
+            if not confirm_callback(confirm_message, "Overwrite Confirmation"):
+                raise click.Abort()
+        else:
+            # Use click.confirm for CLI interaction
+            try:
+                if not click.confirm(
+                    click.style("Overwrite existing files?", fg="yellow"), default=True, show_default=True
+                ):
+                    click.secho("Operation cancelled.", fg="red", err=True)
+                    raise click.Abort()
+            except click.Abort:
+                raise  # Let Abort propagate to be handled by PDDCLI.invoke()
+            except Exception as e: # Catch potential errors during confirm (like EOFError in non-interactive)
+                if 'EOF' in str(e) or 'end-of-file' in str(e).lower():
+                    # Non-interactive environment, default to not overwriting
+                    click.secho("Non-interactive environment detected. Use --force to overwrite existing files.", fg="yellow", err=True)
+                else:
+                    click.secho(f"Confirmation failed: {e}. Aborting.", fg="red", err=True)
+                raise click.Abort()
 
 
     # ------------- Final reporting ---------------------------
@@ -661,7 +854,14 @@ def construct_paths(
     resolved_config["prompts_dir"] = str(next(iter(input_paths.values())).parent)
     resolved_config["code_dir"] = str(gen_path.parent)
     resolved_config["tests_dir"] = str(Path(resolved_config.get("test_output_path", "tests")).parent)
-    resolved_config["examples_dir"] = str(Path(resolved_config.get("example_output_path", "examples")).parent)
+    # example_output_path can be a directory (e.g., "context/") or a file path (e.g., "examples/foo.py")
+    # If it ends with / or has no file extension, treat as directory; otherwise use parent
+    example_path_str = resolved_config.get("example_output_path", "examples")
+    example_path = Path(example_path_str)
+    if example_path_str.endswith('/') or '.' not in example_path.name:
+        resolved_config["examples_dir"] = example_path_str.rstrip('/')
+    else:
+        resolved_config["examples_dir"] = str(example_path.parent)
 
 
-    return resolved_config, input_strings, output_file_paths_str_return, language
+    return resolved_config, input_strings, output_file_paths_str_return, language

pdd/context_generator.py

@@ -16,6 +16,9 @@ def context_generator(
     temperature: float = 0,
     time: Optional[float] = DEFAULT_TIME,
     verbose: bool = False,
+    source_file_path: str = None,
+    example_file_path: str = None,
+    module_name: str = None,
 ) -> tuple:
     """
     Generates a concise example on how to use a given code module properly.
@@ -79,7 +82,10 @@ def context_generator(
             input_json={
                 "code_module": code_module,
                 "processed_prompt": processed_prompt,
-                "language": language
+                "language": language,
+                "source_file_path": source_file_path or "",
+                "example_file_path": example_file_path or "",
+                "module_name": module_name or ""
             },
             strength=strength,
             temperature=temperature,
@@ -95,6 +101,7 @@ def context_generator(
                 strength=0.5,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
         except Exception as e:
@@ -112,6 +119,7 @@ def context_generator(
                 strength=strength,
                 temperature=temperature,
                 time=time,
+                language=language,
                 verbose=verbose
             )
             total_cost = llm_response['cost'] + unfinished_cost + continue_cost
@@ -149,4 +157,4 @@ if __name__ == "__main__":
         print("[bold green]Generated Example Code:[/bold green]")
         print(example_code)
         print(f"[bold blue]Total Cost: ${total_cost:.6f}[/bold blue]")
-        print(f"[bold blue]Model Name: {model_name}[/bold blue]")
+        print(f"[bold blue]Model Name: {model_name}[/bold blue]")