pdd-cli 0.0.55__py3-none-any.whl → 0.0.57__py3-none-any.whl

pdd/code_generator_main.py

@@ -79,6 +79,27 @@ def _expand_vars(text: str, vars_map: Optional[Dict[str, str]]) -> str:
     return text
 
 
+def _parse_front_matter(text: str) -> Tuple[Optional[Dict[str, Any]], str]:
+    """Parse YAML front matter at the start of a prompt and return (meta, body)."""
+    try:
+        if not text.startswith("---\n"):
+            return None, text
+        end_idx = text.find("\n---", 4)
+        if end_idx == -1:
+            return None, text
+        fm_body = text[4:end_idx]
+        rest = text[end_idx + len("\n---"):]
+        if rest.startswith("\n"):
+            rest = rest[1:]
+        import yaml as _yaml
+        meta = _yaml.safe_load(fm_body) or {}
+        if not isinstance(meta, dict):
+            meta = {}
+        return meta, rest
+    except Exception:
+        return None, text
+
+
 def get_git_content_at_ref(file_path: str, git_ref: str = "HEAD") -> Optional[str]:
     """Gets the content of the file as it was at the specified git_ref."""
     abs_file_path = pathlib.Path(file_path).resolve()
@@ -184,8 +205,13 @@ def code_generator_main(
             quiet=quiet,
             command="generate",
             command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
         prompt_content = input_strings["prompt_file"]
+        # Phase-2 templates: parse front matter metadata
+        fm_meta, body = _parse_front_matter(prompt_content)
+        if fm_meta:
+            prompt_content = body
         # Determine final output path: if user passed a directory, use resolved file path
         resolved_output = output_file_paths.get("output")
         if output is None:
@@ -211,10 +237,108 @@ def code_generator_main(
     existing_code_content: Optional[str] = None
     original_prompt_content_for_incremental: Optional[str] = None
 
+    # Merge -e vars with front-matter defaults; validate required
+    if env_vars is None:
+        env_vars = {}
+    if fm_meta and isinstance(fm_meta.get("variables"), dict):
+        for k, spec in (fm_meta["variables"].items()):
+            if isinstance(spec, dict):
+                if k not in env_vars and "default" in spec:
+                    env_vars[k] = str(spec["default"])
+            # if scalar default allowed, ignore for now
+        missing = [k for k, spec in fm_meta["variables"].items() if isinstance(spec, dict) and spec.get("required") and k not in env_vars]
+        if missing:
+            console.print(f"[error]Missing required variables: {', '.join(missing)}")
+            return "", False, 0.0, "error"
+
+    # Execute optional discovery from front matter to populate env_vars without overriding explicit -e values
+    def _run_discovery(discover_cfg: Dict[str, Any]) -> Dict[str, str]:
+        results: Dict[str, str] = {}
+        try:
+            if not discover_cfg:
+                return results
+            enabled = discover_cfg.get("enabled", False)
+            if not enabled:
+                return results
+            root = discover_cfg.get("root", ".")
+            patterns = discover_cfg.get("patterns", []) or []
+            exclude = discover_cfg.get("exclude", []) or []
+            max_per = int(discover_cfg.get("max_per_pattern", 0) or 0)
+            max_total = int(discover_cfg.get("max_total", 0) or 0)
+            root_path = pathlib.Path(root).resolve()
+            seen: List[str] = []
+            def _match_one(patterns_list: List[str]) -> List[str]:
+                matches: List[str] = []
+                for pat in patterns_list:
+                    globbed = list(root_path.rglob(pat))
+                    for p in globbed:
+                        if any(p.match(ex) for ex in exclude):
+                            continue
+                        sp = str(p.resolve())
+                        if sp not in matches:
+                            matches.append(sp)
+                    if max_per and len(matches) >= max_per:
+                        matches = matches[:max_per]
+                        break
+                return matches
+            # If a mapping 'set' is provided, compute per-variable results
+            set_map = discover_cfg.get("set") or {}
+            if isinstance(set_map, dict) and set_map:
+                for var_name, spec in set_map.items():
+                    if var_name in env_vars:
+                        continue  # don't override explicit -e
+                    v_patterns = spec.get("patterns", []) if isinstance(spec, dict) else []
+                    v_exclude = spec.get("exclude", []) if isinstance(spec, dict) else []
+                    save_exclude = exclude
+                    try:
+                        if v_exclude:
+                            exclude = v_exclude
+                        matches = _match_one(v_patterns or patterns)
+                    finally:
+                        exclude = save_exclude
+                    if matches:
+                        results[var_name] = ",".join(matches)
+                        seen.extend(matches)
+            # Fallback: populate SCAN_FILES and SCAN metadata
+            if not results:
+                files = _match_one(patterns)
+                if max_total and len(files) > max_total:
+                    files = files[:max_total]
+                if files:
+                    results["SCAN_FILES"] = ",".join(files)
+            # Always set root/patterns helpers
+            if root:
+                results.setdefault("SCAN_ROOT", str(root_path))
+            if patterns:
+                results.setdefault("SCAN_PATTERNS", ",".join(patterns))
+        except Exception as e:
+            if verbose and not quiet:
+                console.print(f"[yellow]Discovery skipped due to error: {e}[/yellow]")
+        return results
+
+    if fm_meta and isinstance(fm_meta.get("discover"), dict):
+        discovered = _run_discovery(fm_meta.get("discover") or {})
+        for k, v in discovered.items():
+            if k not in env_vars:
+                env_vars[k] = v
+
     # Expand variables in output path if provided
     if output_path:
         output_path = _expand_vars(output_path, env_vars)
 
+    # Honor front-matter output when CLI did not pass --output
+    if output is None and fm_meta and isinstance(fm_meta.get("output"), str):
+        try:
+            meta_out = _expand_vars(fm_meta["output"], env_vars)
+            if meta_out:
+                output_path = str(pathlib.Path(meta_out).resolve())
+        except Exception:
+            pass
+
+    # Honor front-matter language if provided (overrides detection for both local and cloud)
+    if fm_meta and isinstance(fm_meta.get("language"), str) and fm_meta.get("language"):
+        language = fm_meta.get("language")
+
     if output_path and pathlib.Path(output_path).exists():
         try:
             existing_code_content = pathlib.Path(output_path).read_text(encoding="utf-8")
@@ -461,9 +585,11 @@ def code_generator_main(
                 local_prompt = pdd_preprocess(prompt_content, recursive=True, double_curly_brackets=False, exclude_keys=[])
                 local_prompt = _expand_vars(local_prompt, env_vars)
                 local_prompt = pdd_preprocess(local_prompt, recursive=False, double_curly_brackets=True, exclude_keys=[])
+                # Language already resolved (front matter overrides detection if present)
+                gen_language = language
                 generated_code_content, total_cost, model_name = local_code_generator_func(
                     prompt=local_prompt,
-                    language=language,
+                    language=gen_language,
                     strength=strength,
                     temperature=temperature,
                     time=time_budget,
@@ -475,14 +601,37 @@ def code_generator_main(
                     console.print(Panel(f"Full generation successful. Model: {model_name}, Cost: ${total_cost:.6f}", title="[green]Local Success[/green]", expand=False))
         
         if generated_code_content is not None:
+            # Optional output_schema JSON validation before writing
+            try:
+                if fm_meta and isinstance(fm_meta.get("output_schema"), dict):
+                    is_json_output = False
+                    if isinstance(language, str) and str(language).lower().strip() == "json":
+                        is_json_output = True
+                    elif output_path and str(output_path).lower().endswith(".json"):
+                        is_json_output = True
+                    if is_json_output:
+                        parsed = json.loads(generated_code_content)
+                        try:
+                            import jsonschema  # type: ignore
+                            jsonschema.validate(instance=parsed, schema=fm_meta.get("output_schema"))
+                        except ModuleNotFoundError:
+                            if verbose and not quiet:
+                                console.print("[yellow]jsonschema not installed; skipping schema validation.[/yellow]")
+                        except Exception as ve:
+                            raise click.UsageError(f"Generated JSON does not match output_schema: {ve}")
+            except json.JSONDecodeError as jde:
+                raise click.UsageError(f"Generated output is not valid JSON: {jde}")
+
             if output_path:
                 p_output = pathlib.Path(output_path)
                 p_output.parent.mkdir(parents=True, exist_ok=True)
                 p_output.write_text(generated_code_content, encoding="utf-8")
                 if verbose or not quiet:
                     console.print(f"Generated code saved to: [green]{p_output.resolve()}[/green]")
-            elif not quiet: # No output path, print to console if not quiet
-                console.print(Panel(Text(generated_code_content, overflow="fold"), title="[cyan]Generated Code[/cyan]", expand=True))
+            elif not quiet:
+                # No destination resolved; surface the generated code directly to the console.
+                console.print(Panel(Text(generated_code_content, overflow="fold"), title="[cyan]Generated Code[/cyan]", expand=False))
+                console.print("[yellow]No output path resolved; skipping file write and stdout print.[/yellow]")
         else:
             console.print("[red]Error: Code generation failed. No code was produced.[/red]")
             return "", was_incremental_operation, total_cost, model_name or "error"

pdd/conflicts_main.py

@@ -33,7 +33,8 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="conflicts",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Load input files
@@ -91,4 +92,4 @@ def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optio
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)

pdd/construct_paths.py

@@ -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:
@@ -193,7 +210,9 @@ def _is_known_language(language_name: str) -> bool:
     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'
+        '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')
@@ -619,7 +638,9 @@ def construct_paths(
             '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': ''
+            '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 '')
 

pdd/context_generator_main.py

@@ -31,7 +31,8 @@ def context_generator_main(ctx: click.Context, prompt_file: str, code_file: str,
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="example",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Load input files

pdd/crash_main.py

@@ -77,7 +77,8 @@ def crash_main(
             force=force,
             quiet=quiet,
             command="crash",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         prompt_content = input_strings["prompt_file"]
@@ -177,4 +178,4 @@ def crash_main(
     except Exception as e:
         if not quiet:
             rprint(f"[bold red]An unexpected error occurred:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)

pdd/data/language_format.csv

@@ -30,6 +30,7 @@ Groovy,//,.groovy
 Dart,//,.dart
 F#,//,.fs
 YAML,#,.yml
+YAML,#,.yaml
 JSON,del,.json
 JSONL,del,.jsonl
 XML,"<!-- -->",.xml
@@ -60,4 +61,6 @@ LLM,del,.prompt
 prompt,del,.prompt
 TOML,#,.toml
 Log,del,.log
-reStructuredText,del,.rst
+reStructuredText,del,.rst
+Text,del,.txt
+INI,;,.ini

pdd/detect_change_main.py

@@ -44,7 +44,8 @@ def detect_change_main(
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="detect",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Get change description content
@@ -100,4 +101,4 @@ def detect_change_main(
     except Exception as e:
         if not ctx.obj.get('quiet', False):
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        sys.exit(1)

pdd/fix_main.py

@@ -97,7 +97,8 @@ def fix_main(
             quiet=ctx.obj.get('quiet', False),
             command="fix",
             command_options=command_options,
-            create_error_file=loop  # Only create error file if in loop mode
+            create_error_file=loop,  # Only create error file if in loop mode
+            context_override=ctx.obj.get('context')
         )
 
         # Get parameters from context
@@ -296,4 +297,4 @@ def fix_main(
                  # Print other errors normally, escaping the error string
                  from rich.markup import escape # Ensure escape is imported
                  rprint(f"[bold red]Error:[/bold red] {escape(str(e))}")
-        sys.exit(1)
+        sys.exit(1)

pdd/fix_verification_main.py

@@ -204,6 +204,7 @@ def fix_verification_main(
             quiet=quiet,
             command="verify",
             command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
         output_code_path = output_file_paths.get("output_code")
         output_results_path = output_file_paths.get("output_results")

pdd/preprocess.py

@@ -48,7 +48,9 @@ def process_backtick_includes(text: str, recursive: bool) -> str:
                 return f"```{content}```"
         except FileNotFoundError:
             console.print(f"[bold red]Warning:[/bold red] File not found: {file_path}")
-            return match.group(0)
+            # First pass (recursive=True): leave the tag so a later env expansion can resolve it
+            # Second pass (recursive=False): replace with a visible placeholder
+            return match.group(0) if recursive else f"```[File not found: {file_path}]```"
         except Exception as e:
             console.print(f"[bold red]Error processing include:[/bold red] {str(e)}")
             return f"```[Error processing include: {file_path}]```"
@@ -62,9 +64,9 @@ def process_backtick_includes(text: str, recursive: bool) -> str:
 def process_xml_tags(text: str, recursive: bool) -> str:
     text = process_pdd_tags(text)
     text = process_include_tags(text, recursive)
-
-    text = process_shell_tags(text)
-    text = process_web_tags(text)
+    text = process_include_many_tags(text, recursive)
+    text = process_shell_tags(text, recursive)
+    text = process_web_tags(text, recursive)
     return text
 
 def process_include_tags(text: str, recursive: bool) -> str:
@@ -81,7 +83,9 @@ def process_include_tags(text: str, recursive: bool) -> str:
                 return content
         except FileNotFoundError:
             console.print(f"[bold red]Warning:[/bold red] File not found: {file_path}")
-            return f"[File not found: {file_path}]"
+            # First pass (recursive=True): leave the tag so a later env expansion can resolve it
+            # Second pass (recursive=False): replace with a visible placeholder
+            return match.group(0) if recursive else f"[File not found: {file_path}]"
         except Exception as e:
             console.print(f"[bold red]Error processing include:[/bold red] {str(e)}")
             return f"[Error processing include: {file_path}]"
@@ -101,10 +105,13 @@ def process_pdd_tags(text: str) -> str:
         return "This is a test "
     return processed
 
-def process_shell_tags(text: str) -> str:
+def process_shell_tags(text: str, recursive: bool) -> str:
     pattern = r'<shell>(.*?)</shell>'
     def replace_shell(match):
         command = match.group(1).strip()
+        if recursive:
+            # Defer execution until after env var expansion
+            return match.group(0)
         console.print(f"Executing shell command: [cyan]{escape(command)}[/cyan]")
         try:
             result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
@@ -118,10 +125,13 @@ def process_shell_tags(text: str) -> str:
             return f"[Shell execution error: {str(e)}]"
     return re.sub(pattern, replace_shell, text, flags=re.DOTALL)
 
-def process_web_tags(text: str) -> str:
+def process_web_tags(text: str, recursive: bool) -> str:
     pattern = r'<web>(.*?)</web>'
     def replace_web(match):
         url = match.group(1).strip()
+        if recursive:
+            # Defer network operations until after env var expansion
+            return match.group(0)
         console.print(f"Scraping web content from: [cyan]{url}[/cyan]")
         try:
             try:
@@ -144,6 +154,34 @@ def process_web_tags(text: str) -> str:
             return f"[Web scraping error: {str(e)}]"
     return re.sub(pattern, replace_web, text, flags=re.DOTALL)
 
+def process_include_many_tags(text: str, recursive: bool) -> str:
+    """Process <include-many> blocks whose inner content is a comma- or newline-separated
+    list of file paths (typically provided via variables after env expansion)."""
+    pattern = r'<include-many>(.*?)</include-many>'
+    def replace_many(match):
+        inner = match.group(1)
+        if recursive:
+            # Wait for env expansion to materialize the list
+            return match.group(0)
+        # Split by newlines or commas
+        raw_items = [s.strip() for part in inner.split('\n') for s in part.split(',')]
+        paths = [p for p in raw_items if p]
+        contents: list[str] = []
+        for p in paths:
+            try:
+                full_path = get_file_path(p)
+                console.print(f"Including (many): [cyan]{full_path}[/cyan]")
+                with open(full_path, 'r', encoding='utf-8') as fh:
+                    contents.append(fh.read())
+            except FileNotFoundError:
+                console.print(f"[bold red]Warning:[/bold red] File not found: {p}")
+                contents.append(f"[File not found: {p}]")
+            except Exception as e:
+                console.print(f"[bold red]Error processing include-many:[/bold red] {str(e)}")
+                contents.append(f"[Error processing include: {p}]")
+        return "\n".join(contents)
+    return re.sub(pattern, replace_many, text, flags=re.DOTALL)
+
 def double_curly(text: str, exclude_keys: Optional[List[str]] = None) -> str:
     if exclude_keys is None:
         exclude_keys = []

pdd/preprocess_main.py

@@ -33,6 +33,7 @@ def preprocess_main(
             quiet=ctx.obj.get("quiet", False),
             command="preprocess",
             command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Load prompt file
@@ -76,4 +77,4 @@ def preprocess_main(
     except Exception as e:
         if not ctx.obj.get("quiet", False):
             rprint(f"[bold red]Error during preprocessing:[/bold red] {e}")
-        sys.exit(1)
+        sys.exit(1)

pdd/prompts/extract_promptline_LLM.prompt

@@ -1,11 +1,17 @@
-% You are an expert Software Engineer. Your goal is to extract the closest matching substring described by the prompt's output to be outputed in JSON format.
-
-% Here is the llm_output to parse: <llm_output>{llm_output}</llm_output>
-
-% When extracting the closest matching substring from llm_output, consider and correct the following for the extracted code:
-    - Should be a substring of prompt_file.
-    - Should be a a substring that closely matches code_str in content.
-
-% Output a JSON object with the following keys:
-    - 'explanation': String explanation of why this prompt_line matches the code_str and explain any errors detected in the code.
-    - 'prompt_line': String containing the closest matching verbatim substring of the prompt_file that matches code_str in content. This is not the line number.
+% You are an extremely literal parser. The LLM output below follows this structure:
+%   <analysis> ... </analysis>
+%   <verbatim_prompt_line>
+%   <<EXACT SUBSTRING FROM PROMPT_FILE>>
+%   </verbatim_prompt_line>
+%
+% Task
+%   • Extract the text between <verbatim_prompt_line> and </verbatim_prompt_line> (if present).
+%   • Output ONLY JSON with the keys:
+%       - "prompt_line": the exact substring between the tags. Do not alter whitespace or characters except for JSON escaping.
+%       - "explanation": short confirmation (<=120 characters) that the substring was copied verbatim, or describe why extraction failed.
+%   • If the tags are missing or empty, set "prompt_line" to "" and explain the issue.
+%   • Do not wrap the JSON in Markdown. No commentary, no additional keys.
+%
+<llm_output>
+{llm_output}
+</llm_output>

pdd/prompts/trace_LLM.prompt

@@ -1,30 +1,33 @@
-% Imagine you're a an expert Python Software Engineer. Your goal is to find the part of the .prompt file. It will take in three arguments, the text of the .prompt file, the text of the code file, and the line that the debugger is on in the code file. Your task is to find the equivalent line in the .prompt file that matches with the line in the code file.
-
-% Here are the inputs and outputs of the prompt:
-    Input:
-        `code_file` (str) - A string that contains the text of the code file.
-        `code_str` (str) - A substring of code_file that represents the line that the debugger is on in the code_file.
-        `prompt_file` (str) - A string that contains the text of the .prompt file.
-    Output:
-        `prompt_line` (str) - An string that represents the equivalent line in the .prompt file that matches with the code_str line in the code file.
-
-% Here is the code_file to reference: 
-
+% You are a highly accurate Python Software Engineer. Your job is to locate the exact line (or smallest excerpt) in the prompt file that produced the current line in the generated code.
+
+% Inputs
+    code_file (str)    : full contents of the generated code file
+    code_str (str)     : the single line from the code file currently under inspection
+    prompt_file (str)  : full contents of the originating prompt file
+
+% Rules
+1. Identify the minimal substring in prompt_file whose wording most directly corresponds to code_str. Copy it VERBATIM.
+2. Do not paraphrase, summarize, or reformat; the substring must appear exactly in prompt_file.
+3. If multiple lines apply, choose the most specific line or snippet (prefer the shortest exact match).
+4. Provide a short explanation of why the substring matches code_str.
+
+% Output format (MUST follow exactly; no additional text)
+<analysis>
+Explain your reasoning here in plain text (no JSON). Reference the file sections you compared.
+</analysis>
+<verbatim_prompt_line>
+<<PASTE THE EXACT SUBSTRING FROM prompt_file HERE>>
+</verbatim_prompt_line>
+
+% Reference materials
 <code_file>
-    {CODE_FILE}
+{CODE_FILE}
 </code_file>
 
-% Here is the code_str to reference:
-
 <code_str>
-    {CODE_STR}
+{CODE_STR}
 </code_str>
 
-% Here is the prompt_file to reference:
-
 <prompt_file>
-    {PROMPT_FILE}
+{PROMPT_FILE}
 </prompt_file>
-
-% To generate the prompt_line, find a substring of prompt_file that matches code_str, which is a substring of code_file.
-

pdd/split_main.py

@@ -53,7 +53,8 @@ def split_main(
             force=ctx.obj.get('force', False),
             quiet=ctx.obj.get('quiet', False),
             command="split",
-            command_options=command_options
+            command_options=command_options,
+            context_override=ctx.obj.get('context')
         )
 
         # Get parameters from context
@@ -113,4 +114,4 @@ def split_main(
             elif isinstance(e, ValueError):
                 rprint("[yellow]Hint: Check if input files have valid content.[/yellow]")
         
-        sys.exit(1)
+        sys.exit(1)