flock-core 0.3.18__py3-none-any.whl → 0.3.21__py3-none-any.whl

flock/__init__.py

@@ -3,6 +3,8 @@
 from flock.cli.constants import CLI_EXIT, CLI_NOTES, CLI_THEME_BUILDER
 from flock.cli.load_release_notes import load_release_notes
 from flock.core.logging.formatters.theme_builder import theme_builder
+from flock.cli.settings import settings_editor
+from rich.panel import Panel
 
 
 def main():
@@ -27,7 +29,9 @@ def main():
     while True:
         init_console()
 
-        console.print("Flock Management Console\n", style="bold green")
+        #console.print("Flock Management Console\n", style="bold green")
+        console.print(Panel("[bold green]Flock Management Console[/]"), justify="center")
+        console.line()
 
         result = questionary.select(
             "What do you want to do?",
@@ -54,6 +58,8 @@ def main():
             load_flock()
         if result == CLI_THEME_BUILDER:
             theme_builder()
+        if result == CLI_SETTINGS:
+            settings_editor()
         if result == CLI_NOTES:
             load_release_notes()
         if result == CLI_EXIT:

flock/cli/settings.py

@@ -1 +1,857 @@
-# TODO
+"""Settings editor for the Flock CLI.
+
+This module provides functionality to view, edit, add, and delete
+environment variables in the .env file.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import math
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from flock.core.util.cli_helper import init_console
+
+# Constants
+ENV_FILE = ".env"
+ENV_TEMPLATE_FILE = ".env_template"
+ENV_PROFILE_PREFIX = ".env_"
+DEFAULT_PROFILE_COMMENT = "# Profile: {profile_name}"
+SHOW_SECRETS_KEY = "SHOW_SECRETS"
+VARS_PER_PAGE_KEY = "VARS_PER_PAGE"
+DEFAULT_VARS_PER_PAGE = 20
+
+console = Console()
+
+
+def settings_editor():
+    """Main entry point for the settings editor."""
+    while True:
+        init_console()
+        console.print(Panel("[bold green]Environment Settings Editor[/]"), justify="center")
+        
+        # Get current profile name
+        current_profile = get_current_profile()
+        if current_profile:
+            console.print(f"Current Profile: [bold cyan]{current_profile}[/]")
+        else:
+            console.print("No profile detected")
+
+        console.line()
+            
+        choice = questionary.select(
+            "What would you like to do?",
+            choices=[
+                questionary.Separator(line=" "),
+                "View all environment variables",
+                "Edit an environment variable",
+                "Add a new environment variable",
+                "Delete an environment variable",
+                questionary.Separator(),
+                "Manage environment profiles",
+                questionary.Separator(),
+                "Toggle show secrets",
+                "Change variables per page",
+                questionary.Separator(),
+                "Back to main menu",
+            ],
+        ).ask()
+        
+        if choice == "View all environment variables":
+            view_env_variables()
+        elif choice == "Edit an environment variable":
+            edit_env_variable()
+        elif choice == "Add a new environment variable":
+            add_env_variable()
+        elif choice == "Delete an environment variable":
+            delete_env_variable()
+        elif choice == "Manage environment profiles":
+            manage_profiles()
+        elif choice == "Toggle show secrets":
+            toggle_show_secrets()
+        elif choice == "Change variables per page":
+            change_vars_per_page()
+        elif choice == "Back to main menu":
+            break
+        
+        if choice != "Back to main menu":
+            input("\nPress Enter to continue...")
+
+
+def view_env_variables(page: int = 1, page_size: Optional[int] = None):
+    """View all environment variables with pagination.
+    
+    Args:
+        page: Page number to display
+        page_size: Number of variables per page (if None, use the setting in .env)
+    """
+    env_vars = load_env_file()
+    
+    # If page_size is not specified, get it from settings
+    if page_size is None:
+        page_size = get_vars_per_page_setting(env_vars)
+    
+    # Calculate pagination
+    total_vars = len(env_vars)
+    total_pages = math.ceil(total_vars / page_size) if total_vars > 0 else 1
+    
+    # Validate page number
+    page = min(max(1, page), total_pages)
+    
+    start_idx = (page - 1) * page_size
+    end_idx = min(start_idx + page_size, total_vars)
+    
+    # Get current page variables
+    current_page_vars = list(env_vars.items())[start_idx:end_idx]
+    
+    # Check if secrets should be shown
+    show_secrets = get_show_secrets_setting(env_vars)
+    
+    # Create table
+    table = Table(title=f"Environment Variables (Page {page}/{total_pages}, {page_size} per page)")
+    table.add_column("Name", style="cyan")
+    table.add_column("Value", style="green")
+    
+    # Show secrets status
+    secrets_status = "[green]ON[/]" if show_secrets else "[red]OFF[/]"
+    init_console()
+    console.print(f"Show Secrets: {secrets_status}")
+    
+    for key, value in current_page_vars:
+        # Skip lines that are comments or empty
+        if key.startswith('#') or not key:
+            continue
+            
+        # Mask sensitive values if show_secrets is False
+        if is_sensitive(key) and not show_secrets:
+            masked_value = mask_sensitive_value(value)
+            table.add_row(key, masked_value)
+        else:
+            table.add_row(key, value)
+    
+    console.print(table)
+    
+    # Pagination controls with more intuitive shortcuts
+    console.print("\nNavigation: ", end="")
+    if page > 1:
+        console.print("[bold]Previous (p)[/] | ", end="")
+    if page < total_pages:
+        console.print("[bold]Next (n)[/] | ", end="")
+    if show_secrets:
+        console.print("[bold]Hide secrets (h)[/] | ", end="")
+    else:
+        console.print("[bold]Show secrets (s)[/] | ", end="")
+    console.print("[bold]Change variables per page (v)[/] | ", end="")
+    console.print("[bold]Back (b)[/]")
+    
+    # Handle navigation
+    while True:
+        key = input("Enter option: ").lower()
+        if key == 'p' and page > 1:
+            view_env_variables(page - 1, page_size)
+            break
+        elif key == 'n' and page < total_pages:
+            view_env_variables(page + 1, page_size)
+            break
+        elif key == 's' and not show_secrets:
+            # Confirm showing secrets
+            confirm = questionary.confirm("Are you sure you want to show sensitive values?").ask()
+            if confirm:
+                set_show_secrets_setting(True)
+                view_env_variables(page, page_size)
+            break
+        elif key == 'h' and show_secrets:
+            set_show_secrets_setting(False)
+            view_env_variables(page, page_size)
+            break
+        elif key == 'v':
+            new_page_size = change_vars_per_page()
+            if new_page_size:
+                view_env_variables(1, new_page_size)  # Reset to first page with new page size
+            break
+        elif key == 'b':
+            break
+
+
+def change_vars_per_page():
+    """Change the number of variables displayed per page.
+    
+    Returns:
+        The new page size or None if cancelled
+    """
+    env_vars = load_env_file()
+    current_setting = get_vars_per_page_setting(env_vars)
+    
+    console.print(f"Current variables per page: [cyan]{current_setting}[/]")
+    
+    # Predefined options plus custom option
+    page_size_options = ["10", "20", "30", "50", "Custom", "Cancel"]
+    
+    choice = questionary.select(
+        "Select number of variables per page:",
+        choices=page_size_options,
+    ).ask()
+    
+    if choice == "Cancel":
+        return None
+    
+    if choice == "Custom":
+        while True:
+            try:
+                custom_size = questionary.text(
+                    "Enter custom page size (5-100):",
+                    default=str(current_setting)
+                ).ask()
+                
+                if not custom_size:
+                    return None
+                
+                new_size = int(custom_size)
+                if 5 <= new_size <= 100:
+                    break
+                else:
+                    console.print("[yellow]Page size must be between 5 and 100.[/]")
+            except ValueError:
+                console.print("[yellow]Please enter a valid number.[/]")
+    else:
+        new_size = int(choice)
+    
+    # Save the setting
+    set_vars_per_page_setting(new_size)
+    console.print(f"[green]Variables per page set to {new_size}.[/]")
+    
+    return new_size
+
+
+def get_vars_per_page_setting(env_vars: Dict[str, str] = None) -> int:
+    """Get the current variables per page setting.
+    
+    Args:
+        env_vars: Optional dictionary of environment variables
+        
+    Returns:
+        Number of variables per page
+    """
+    if env_vars is None:
+        env_vars = load_env_file()
+    
+    if VARS_PER_PAGE_KEY in env_vars:
+        try:
+            page_size = int(env_vars[VARS_PER_PAGE_KEY])
+            # Ensure the value is within reasonable bounds
+            if 5 <= page_size <= 100:
+                return page_size
+        except ValueError:
+            pass
+    
+    return DEFAULT_VARS_PER_PAGE
+
+
+def set_vars_per_page_setting(page_size: int):
+    """Set the variables per page setting.
+    
+    Args:
+        page_size: Number of variables to display per page
+    """
+    env_vars = load_env_file()
+    env_vars[VARS_PER_PAGE_KEY] = str(page_size)
+    save_env_file(env_vars)
+
+
+def toggle_show_secrets():
+    """Toggle the show secrets setting."""
+    env_vars = load_env_file()
+    current_setting = get_show_secrets_setting(env_vars)
+    
+    if current_setting:
+        console.print("Currently showing sensitive values. Do you want to hide them?")
+        confirm = questionary.confirm("Hide sensitive values?").ask()
+        if confirm:
+            set_show_secrets_setting(False)
+            console.print("[green]Sensitive values will now be masked.[/]")
+    else:
+        console.print("[yellow]Warning:[/] Showing sensitive values can expose sensitive information.")
+        confirm = questionary.confirm("Are you sure you want to show sensitive values?").ask()
+        if confirm:
+            set_show_secrets_setting(True)
+            console.print("[green]Sensitive values will now be shown.[/]")
+
+
+def get_show_secrets_setting(env_vars: Dict[str, str] = None) -> bool:
+    """Get the current show secrets setting.
+    
+    Args:
+        env_vars: Optional dictionary of environment variables
+        
+    Returns:
+        True if secrets should be shown, False otherwise
+    """
+    if env_vars is None:
+        env_vars = load_env_file()
+    
+    if SHOW_SECRETS_KEY in env_vars:
+        return env_vars[SHOW_SECRETS_KEY].lower() == 'true'
+    
+    return False
+
+
+def set_show_secrets_setting(show_secrets: bool):
+    """Set the show secrets setting.
+    
+    Args:
+        show_secrets: Whether to show secrets
+    """
+    env_vars = load_env_file()
+    env_vars[SHOW_SECRETS_KEY] = str(show_secrets)
+    save_env_file(env_vars)
+
+
+def edit_env_variable():
+    """Edit an environment variable."""
+    # Get list of variables
+    env_vars = load_env_file()
+    
+    if not env_vars:
+        console.print("[yellow]No environment variables found to edit.[/]")
+        return
+    
+    # Filter out comments
+    variables = [k for k in env_vars.keys() if not k.startswith('#') and k]
+    
+    # Display variables with selection
+    init_console()
+    console.print("Select a variable to edit:")
+    
+    # Let user select a variable to edit
+    var_name = questionary.select(
+        "Select a variable to edit:",
+        choices=variables + ["Cancel"],
+    ).ask()
+    
+    if var_name == "Cancel":
+        return
+    
+    current_value = env_vars[var_name]
+    is_sensitive_var = is_sensitive(var_name)
+    
+    if is_sensitive_var:
+        console.print(f"[yellow]Warning:[/] You are editing a sensitive value: {var_name}")
+        confirm = questionary.confirm("Are you sure you want to continue?").ask()
+        if not confirm:
+            return
+    
+    # Show current value (masked if sensitive and show_secrets is False)
+    show_secrets = get_show_secrets_setting(env_vars)
+    if is_sensitive_var and not show_secrets:
+        console.print(f"Current value: {mask_sensitive_value(current_value)}")
+    else:
+        console.print(f"Current value: {current_value}")
+    
+    # Get new value with hint
+    console.print("[italic]Enter new value (or leave empty to cancel)[/]")
+    new_value = questionary.text("Enter new value:", default=current_value).ask()
+    
+    if new_value is None:
+        console.print("[yellow]Edit cancelled.[/]")
+        return
+    
+    if new_value == "":
+        # Confirm if user wants to set an empty value or cancel
+        confirm = questionary.confirm("Do you want to set an empty value? Select No to cancel.", default=False).ask()
+        if not confirm:
+            console.print("[yellow]Edit cancelled.[/]")
+            return
+    
+    if new_value == current_value:
+        console.print("[yellow]No changes made.[/]")
+        return
+    
+    # Update the value
+    env_vars[var_name] = new_value
+    save_env_file(env_vars)
+    console.print(f"[green]Updated {var_name} successfully.[/]")
+
+
+def add_env_variable():
+    """Add a new environment variable."""
+    env_vars = load_env_file()
+    
+    console.print("[italic]Enter variable name (or leave empty to go back)[/]")
+    
+    # Get variable name
+    while True:
+        var_name = questionary.text("Enter variable name:").ask()
+        
+        if not var_name:
+            # Ask if user wants to go back
+            go_back = questionary.confirm("Do you want to go back to the settings menu?", default=True).ask()
+            if go_back:
+                return
+            else:
+                console.print("[italic]Please enter a variable name (or leave empty to go back)[/]")
+                continue
+            
+        if var_name in env_vars and not var_name.startswith('#'):
+            console.print(f"[yellow]Variable {var_name} already exists. Please use edit instead.[/]")
+            continue
+            
+        break
+    
+    # Get variable value
+    var_value = questionary.text("Enter variable value:").ask()
+    
+    # Add to env_vars
+    env_vars[var_name] = var_value
+    save_env_file(env_vars)
+    console.print(f"[green]Added {var_name} successfully.[/]")
+
+
+def delete_env_variable():
+    """Delete an environment variable."""
+    # Get list of variables
+    env_vars = load_env_file()
+    
+    if not env_vars:
+        console.print("[yellow]No environment variables found to delete.[/]")
+        return
+    
+    # Filter out comments
+    variables = [k for k in env_vars.keys() if not k.startswith('#') and k]
+    
+    # Display variables with selection
+    init_console()
+    console.print("Select a variable to delete:")
+    
+    # Let user select a variable to delete with hint
+    var_name = questionary.select(
+        "Select a variable to delete:",
+        choices=variables + ["Cancel"],
+    ).ask()
+    
+    if var_name == "Cancel":
+        return
+    
+    # Confirm deletion
+    confirm = questionary.confirm(f"Are you sure you want to delete {var_name}?").ask()
+    if not confirm:
+        console.print("[yellow]Deletion cancelled.[/]")
+        return
+    
+    # Delete the variable
+    del env_vars[var_name]
+    save_env_file(env_vars)
+    console.print(f"[green]Deleted {var_name} successfully.[/]")
+
+
+def manage_profiles():
+    """Manage environment profiles."""
+    init_console()
+    console.print(Panel("[bold green]Environment Profile Management[/]"), justify="center")
+    
+    # Get current profile and available profiles
+    current_profile = get_current_profile()
+    available_profiles = get_available_profiles()
+    
+    if current_profile:
+        console.print(f"Current Profile: [bold cyan]{current_profile}[/]")
+    
+    if not available_profiles:
+        console.print("[yellow]No profiles found.[/]")
+    else:
+        console.print("Available Profiles:")
+        for profile in available_profiles:
+            if profile == current_profile:
+                console.print(f"  [bold cyan]{profile} (active)[/]")
+            else:
+                console.print(f"  {profile}")
+
+    console.line()
+    
+    # Profile management options
+    choice = questionary.select(
+        "What would you like to do?",
+        choices=[
+            questionary.Separator(line=" "),
+            "Switch to a different profile",
+            "Create a new profile",
+            "Rename a profile",
+            "Delete a profile",
+            "Back to settings menu",
+        ],
+    ).ask()
+    
+    if choice == "Switch to a different profile":
+        switch_profile()
+    elif choice == "Create a new profile":
+        create_profile()
+    elif choice == "Rename a profile":
+        rename_profile()
+    elif choice == "Delete a profile":
+        delete_profile()
+
+
+def switch_profile():
+    """Switch to a different environment profile."""
+    available_profiles = get_available_profiles()
+    current_profile = get_current_profile()
+    
+    if not available_profiles:
+        console.print("[yellow]No profiles available to switch to.[/]")
+        return
+    
+    # Remove current profile from the list to avoid switching to the same profile
+    selectable_profiles = [p for p in available_profiles if p != current_profile]
+    
+    if not selectable_profiles:
+        console.print("[yellow]No other profiles available to switch to.[/]")
+        return
+    
+    target_profile = questionary.select(
+        "Select a profile to switch to:",
+        choices=selectable_profiles + ["Cancel"],
+    ).ask()
+    
+    if target_profile == "Cancel":
+        return
+    
+    # Confirm switch
+    confirm = questionary.confirm(f"Are you sure you want to switch to the {target_profile} profile?").ask()
+    if not confirm:
+        return
+    
+    # Backup current .env file
+    backup_env_file()
+    
+    # Copy selected profile to .env
+    source_file = f"{ENV_PROFILE_PREFIX}{target_profile}"
+    if os.path.exists(source_file):
+        shutil.copy2(source_file, ENV_FILE)
+        console.print(f"[green]Switched to {target_profile} profile successfully.[/]")
+    else:
+        console.print(f"[red]Error: Could not find profile file {source_file}.[/]")
+
+
+def create_profile():
+    """Create a new environment profile."""
+    profile_name = questionary.text("Enter new profile name:").ask()
+    
+    if not profile_name:
+        console.print("[yellow]Profile name cannot be empty.[/]")
+        return
+    
+    # Check if profile already exists
+    target_file = f"{ENV_PROFILE_PREFIX}{profile_name}"
+    if os.path.exists(target_file):
+        console.print(f"[yellow]Profile {profile_name} already exists.[/]")
+        return
+    
+    # Determine source file - use current .env or template
+    source_choices = ["Current environment (.env)", ".env_template"]
+    if os.path.exists(ENV_TEMPLATE_FILE):
+        source_choices.append(ENV_TEMPLATE_FILE)
+    
+    source_choice = questionary.select(
+        "Create profile based on:",
+        choices=source_choices + ["Cancel"],
+    ).ask()
+    
+    if source_choice == "Cancel":
+        return
+    
+    source_file = ENV_FILE if source_choice == "Current environment (.env)" else ENV_TEMPLATE_FILE
+    
+    if not os.path.exists(source_file):
+        console.print(f"[red]Error: Source file {source_file} not found.[/]")
+        return
+    
+    # Create new profile file
+    try:
+        # Copy source file
+        shutil.copy2(source_file, target_file)
+        
+        # Add profile header if it doesn't exist
+        with open(target_file, 'r') as file:
+            content = file.read()
+        
+        if not content.startswith("# Profile:"):
+            with open(target_file, 'w') as file:
+                profile_header = DEFAULT_PROFILE_COMMENT.format(profile_name=profile_name)
+                file.write(f"{profile_header}\n{content}")
+        
+        console.print(f"[green]Created {profile_name} profile successfully.[/]")
+    except Exception as e:
+        console.print(f"[red]Error creating profile: {str(e)}[/]")
+
+
+def rename_profile():
+    """Rename an existing profile."""
+    available_profiles = get_available_profiles()
+    current_profile = get_current_profile()
+    
+    if not available_profiles:
+        console.print("[yellow]No profiles available to rename.[/]")
+        return
+    
+    # Let user select a profile to rename
+    profile_to_rename = questionary.select(
+        "Select a profile to rename:",
+        choices=available_profiles + ["Cancel"],
+    ).ask()
+    
+    if profile_to_rename == "Cancel":
+        return
+    
+    # Get new name
+    new_name = questionary.text("Enter new profile name:").ask()
+    
+    if not new_name:
+        console.print("[yellow]New profile name cannot be empty.[/]")
+        return
+    
+    if new_name in available_profiles:
+        console.print(f"[yellow]Profile {new_name} already exists.[/]")
+        return
+    
+    # Rename profile file
+    source_file = f"{ENV_PROFILE_PREFIX}{profile_to_rename}"
+    target_file = f"{ENV_PROFILE_PREFIX}{new_name}"
+    
+    try:
+        # Read content of the source file
+        with open(source_file, 'r') as file:
+            content = file.readlines()
+        
+        # Update profile header if it exists
+        if content and content[0].startswith("# Profile:"):
+            content[0] = DEFAULT_PROFILE_COMMENT.format(profile_name=new_name) + "\n"
+        
+        # Write to new file
+        with open(target_file, 'w') as file:
+            file.writelines(content)
+        
+        # Remove old file
+        os.remove(source_file)
+        
+        # If this was the current profile, update .env as well
+        if profile_to_rename == current_profile:
+            with open(ENV_FILE, 'r') as file:
+                content = file.readlines()
+            
+            if content and content[0].startswith("# Profile:"):
+                content[0] = DEFAULT_PROFILE_COMMENT.format(profile_name=new_name) + "\n"
+            
+            with open(ENV_FILE, 'w') as file:
+                file.writelines(content)
+        
+        console.print(f"[green]Renamed {profile_to_rename} to {new_name} successfully.[/]")
+    except Exception as e:
+        console.print(f"[red]Error renaming profile: {str(e)}[/]")
+
+
+def delete_profile():
+    """Delete an existing profile."""
+    available_profiles = get_available_profiles()
+    current_profile = get_current_profile()
+    
+    if not available_profiles:
+        console.print("[yellow]No profiles available to delete.[/]")
+        return
+    
+    # Let user select a profile to delete
+    profile_to_delete = questionary.select(
+        "Select a profile to delete:",
+        choices=available_profiles + ["Cancel"],
+    ).ask()
+    
+    if profile_to_delete == "Cancel":
+        return
+    
+    # Confirm deletion
+    confirm = questionary.confirm(
+        f"Are you sure you want to delete the {profile_to_delete} profile? This cannot be undone."
+    ).ask()
+    
+    if not confirm:
+        return
+    
+    # Delete profile file
+    profile_file = f"{ENV_PROFILE_PREFIX}{profile_to_delete}"
+    
+    try:
+        os.remove(profile_file)
+        
+        # Warn if deleting the current profile
+        if profile_to_delete == current_profile:
+            console.print(
+                f"[yellow]Warning: You deleted the currently active profile. "
+                f"The .env file still contains those settings but is no longer marked as a profile.[/]"
+            )
+            
+            # Remove profile header from .env
+            with open(ENV_FILE, 'r') as file:
+                content = file.readlines()
+            
+            if content and content[0].startswith("# Profile:"):
+                content = content[1:]
+                with open(ENV_FILE, 'w') as file:
+                    file.writelines(content)
+        
+        console.print(f"[green]Deleted {profile_to_delete} profile successfully.[/]")
+    except Exception as e:
+        console.print(f"[red]Error deleting profile: {str(e)}[/]")
+
+
+def is_sensitive(key: str) -> bool:
+    """Check if a variable is considered sensitive.
+    
+    Args:
+        key: The variable name
+        
+    Returns:
+        True if sensitive, False otherwise
+    """
+    sensitive_patterns = ['key', 'token', 'secret', 'password', 'api', 'pat']
+    key_lower = key.lower()
+    return any(pattern in key_lower for pattern in sensitive_patterns)
+
+
+def mask_sensitive_value(value: str) -> str:
+    """Mask a sensitive value.
+    
+    Args:
+        value: The sensitive value
+        
+    Returns:
+        Masked value
+    """
+    if not value:
+        return value
+    
+    if len(value) <= 4:
+        return "••••"
+    
+    # Show first 2 and last 2 characters
+    return value[:2] + "•" * (len(value) - 4) + value[-2:]
+
+
+def get_current_profile() -> Optional[str]:
+    """Get the name of the current active profile.
+    
+    Returns:
+        Profile name or None if no profile is active
+    """
+    if not os.path.exists(ENV_FILE):
+        return None
+    
+    try:
+        with open(ENV_FILE, 'r') as file:
+            first_line = file.readline().strip()
+            
+        if first_line.startswith("# Profile:"):
+            return first_line.replace("# Profile:", "").strip()
+    except Exception:
+        pass
+    
+    return None
+
+
+def get_available_profiles() -> List[str]:
+    """Get a list of available profiles.
+    
+    Returns:
+        List of profile names
+    """
+    profiles = []
+    
+    for file in os.listdir():
+        if file.startswith(ENV_PROFILE_PREFIX):
+            profile_name = file[len(ENV_PROFILE_PREFIX):]
+            profiles.append(profile_name)
+    
+    return profiles
+
+
+def backup_env_file():
+    """Create a backup of the current .env file."""
+    if not os.path.exists(ENV_FILE):
+        return
+    
+    backup_file = f"{ENV_FILE}.bak"
+    shutil.copy2(ENV_FILE, backup_file)
+
+
+def load_env_file() -> Dict[str, str]:
+    """Load the .env file into a dictionary.
+    
+    Returns:
+        Dictionary of environment variables
+    """
+    env_vars = {}
+    
+    if not os.path.exists(ENV_FILE):
+        console.print(f"[yellow]Warning: {ENV_FILE} file not found.[/]")
+        return env_vars
+    
+    try:
+        with open(ENV_FILE, 'r') as file:
+            lines = file.readlines()
+            
+        # Process each line
+        for line in lines:
+            line = line.strip()
+            
+            # Skip empty lines
+            if not line:
+                env_vars[""] = ""
+                continue
+            
+            # Handle comments
+            if line.startswith('#'):
+                env_vars[line] = ""
+                continue
+            
+            # Handle regular variables
+            if '=' in line:
+                key, value = line.split('=', 1)
+                env_vars[key] = value
+            else:
+                # Handle lines without equals sign
+                env_vars[line] = ""
+                
+    except Exception as e:
+        console.print(f"[red]Error loading .env file: {str(e)}[/]")
+    
+    return env_vars
+
+
+def save_env_file(env_vars: Dict[str, str]):
+    """Save environment variables back to the .env file.
+    
+    Args:
+        env_vars: Dictionary of environment variables
+    """
+    # Create backup
+    backup_env_file()
+    
+    try:
+        with open(ENV_FILE, 'w') as file:
+            for key, value in env_vars.items():
+                if key.startswith('#'):
+                    # Write comments as is
+                    file.write(f"{key}\n")
+                elif not key:
+                    # Write empty lines
+                    file.write("\n")
+                else:
+                    # Write regular variables
+                    file.write(f"{key}={value}\n")
+                    
+        console.print("[green]Settings saved successfully.[/]")
+    except Exception as e:
+        console.print(f"[red]Error saving .env file: {str(e)}[/]")

flock/core/context/context.py

@@ -74,8 +74,8 @@ class FlockContext(Serializable, BaseModel):
                 attributes={"agent": agent_name, "timestamp": timestamp},
             )
 
-    def get_variable(self, key: str) -> Any:
-        return self.state.get(key)
+    def get_variable(self, key: str, default: Any = None) -> Any:
+        return self.state.get(key, default)
 
     def set_variable(self, key: str, value: Any) -> None:
         old_value = self.state.get(key)

flock/core/flock_agent.py

@@ -101,13 +101,6 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         with tracer.start_as_current_span("agent.initialize") as span:
             span.set_attribute("agent.name", self.name)
             span.set_attribute("inputs", str(inputs))
-            if not self.context:
-                self.context = FlockContext()
-
-            if self.name not in self.context.agent_definitions:
-                self.context.add_agent_definition(
-                    type(self), self.name, self.to_dict()
-                )
 
             try:
                 for module in self.get_enabled_modules():
@@ -137,7 +130,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             )
             try:
                 for module in self.get_enabled_modules():
-                    await module.terminate(self, inputs, inputs, self.context)
+                    await module.terminate(self, inputs, result, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",

flock/core/flock_evaluator.py

@@ -20,6 +20,10 @@ class FlockEvaluatorConfig(BaseModel):
             save_after_update: bool = Field(default=True)
     """
 
+    model: str = Field(
+        default="", description="The model to use for evaluation"
+    )
+
     @classmethod
     def with_fields(cls: type[T], **field_definitions) -> type[T]:
         """Create a new config class with additional fields."""

flock/core/flock_factory.py

@@ -36,6 +36,7 @@ class FlockFactory:
         alert_latency_threshold_ms: int = 30000,
         no_output: bool = False,
         print_context: bool = False,
+        write_to_file: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -67,6 +68,7 @@ class FlockFactory:
             wait_for_input=wait_for_input,
             no_output=no_output,
             print_context=print_context,
+            write_to_file=write_to_file,
         )
         output_module = OutputModule("output", config=output_config)
 

flock/core/logging/formatters/themed_formatter.py

@@ -416,7 +416,6 @@ class ThemedAgentResultFormatter:
         max_length: int = -1,
         render_table: bool = True,
         wait_for_input: bool = False,
-        write_to_file: bool = False,
     ):
         """Initialize the formatter with a theme and optional max length."""
         self.theme = theme
@@ -424,7 +423,6 @@ class ThemedAgentResultFormatter:
         self.max_length = max_length
         self.render_table = render_table
         self.wait_for_input = wait_for_input
-        self.write_to_file = write_to_file
 
     def format_result(
         self,
@@ -484,11 +482,6 @@ class ThemedAgentResultFormatter:
 
         s = pformat(result, highlight=False)
 
-        if self.write_to_file:
-            output_file = pathlib.Path(f"{agent_name}_result.txt")
-            with open(output_file, "w") as f:
-                f.write(s)
-
         if self.render_table:
             return Panel(
                 table,

flock/core/serialization/__init__.py

@@ -0,0 +1,7 @@
+"""Serialization utilities for Flock objects."""
+
+from flock.core.serialization.json_encoder import FlockJSONEncoder
+from flock.core.serialization.secure_serializer import SecureSerializer
+from flock.core.serialization.serializable import Serializable
+
+__all__ = ["FlockJSONEncoder", "SecureSerializer", "Serializable"]

flock/core/serialization/json_encoder.py

@@ -0,0 +1,41 @@
+"""JSON encoder utilities for Flock objects."""
+
+import json
+from datetime import datetime
+from typing import Any
+
+
+class FlockJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder for handling Pydantic models and other non-serializable objects."""
+
+    def default(self, obj: Any) -> Any:
+        from pydantic import BaseModel
+
+        # Handle Pydantic models
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
+        # Handle datetime objects
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+
+        # Handle sets, convert to list
+        if isinstance(obj, set):
+            return list(obj)
+
+        # Handle objects with a to_dict method
+        if hasattr(obj, "to_dict") and callable(getattr(obj, "to_dict")):
+            return obj.to_dict()
+
+        # Handle objects with a __dict__ attribute
+        if hasattr(obj, "__dict__"):
+            return {
+                k: v for k, v in obj.__dict__.items() if not k.startswith("_")
+            }
+
+        # Let the parent class handle it or raise TypeError
+        try:
+            return super().default(obj)
+        except TypeError:
+            # If all else fails, convert to string
+            return str(obj)

{flock_core-0.3.18.dist-info → flock_core-0.3.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.18
+Version: 0.3.21
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -19,6 +19,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: msgpack>=1.1.0
+Requires-Dist: notion-client>=2.3.0
 Requires-Dist: opentelemetry-api>=1.30.0
 Requires-Dist: opentelemetry-exporter-jaeger-proto-grpc>=1.21.0
 Requires-Dist: opentelemetry-exporter-jaeger>=1.21.0

{flock_core-0.3.18.dist-info → flock_core-0.3.21.dist-info}/RECORD

@@ -1,4 +1,4 @@
-flock/__init__.py,sha256=9BfhaVhkV3ZadIXp6xpZYlt8_N_OBmQSxxJHwpXYPic,1867
+flock/__init__.py,sha256=49_Z1uLb-fA2InJtNHQleB3NDpfamZGq2S01yttJoVI,2122
 flock/config.py,sha256=O5QJGlStf4DWSK4ovZsKw01ud4YK3_ij6Ay8sWU8ih0,1522
 flock/cli/constants.py,sha256=UWshD25IGos5Ks4P9paGPalY8BXy9YynzHk6HB4xfOo,669
 flock/cli/create_agent.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
@@ -7,17 +7,17 @@ flock/cli/load_agent.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/load_examples.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
-flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
+flock/cli/settings.py,sha256=Z_TXBzCYlCmSaKrJ_CQCdYy-Cj29gpI4kbC_2KzoKqg,27025
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
 flock/core/flock.py,sha256=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
-flock/core/flock_agent.py,sha256=QPyRSa1X_aAK2MSgqLNHBiL-_cnYHOSSnrFup2YTzss,12509
+flock/core/flock_agent.py,sha256=F1wl54ivLQijSHlv_Q_znw_ElzdDlqpi-KugVUyHTRE,12238
 flock/core/flock_api.py,sha256=2rHnmEdtT5KPZYwGesRT7LqwbrgKClODHT-O56u7pcQ,7140
-flock/core/flock_evaluator.py,sha256=j7riJj_KsWoBnKmLiGp-U0CRhxDyJbgEdLGN26tfKm8,1588
-flock/core/flock_factory.py,sha256=7nV0WAh197INdBckJ-NhnhSSZOSzZC1MlYfeZm2x8Xc,2750
+flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
+flock/core/flock_factory.py,sha256=MGTkJCP1WGpV614f87r1vwe0tqAvBCoH9PlqtqDyJDk,2828
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
-flock/core/context/context.py,sha256=3sj5BrnY7OBG8Xk-uoT0yPKQjCzUU6a3VH26xuHo2KI,6407
+flock/core/context/context.py,sha256=8bjRLZ74oacRNBaHmDNXdQKfB-95poF7Pp03n2k0zcQ,6437
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=zYTMi9b6mNSSEHowEQUOTpEDurmAjaUcyBCgfKY6-cU,300
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
@@ -29,7 +29,7 @@ flock/core/logging/telemetry.py,sha256=3E9Tyj6AUR6A5RlIufcdCdWm5BAA7tbOsCa7lHoUQ
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/enum_builder.py,sha256=LgEYXUv84wK5vwHflZ5h8HBGgvLH3sByvUQe8tZiyY0,981
 flock/core/logging/formatters/theme_builder.py,sha256=Wnaal3HuUDA4HFg9tdql1BxYwK83ACOZBBQy-DXnxcA,17342
-flock/core/logging/formatters/themed_formatter.py,sha256=6WO9RPr6Su05rJEX9bRXd8peE-QzGCQeO5veIjQH-Vc,21086
+flock/core/logging/formatters/themed_formatter.py,sha256=kCmGXLD8yzhfzENJUQOsqX3Sdo2PuN8JIZvBBWO22JI,20834
 flock/core/logging/formatters/themes.py,sha256=80BRJJB0LZr11N0yQw2f8vdb_9179qjQO8PoeBaLMN0,10680
 flock/core/logging/span_middleware/baggage_span_processor.py,sha256=gJfRl8FeB6jdtghTaRHCrOaTo4fhPMRKgjqtZj-8T48,1118
 flock/core/logging/telemetry_exporter/base_exporter.py,sha256=rQJJzS6q9n2aojoSqwCnl7ZtHrh5LZZ-gkxUuI5WfrQ,1124
@@ -38,6 +38,8 @@ flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6
 flock/core/mixin/dspy_integration.py,sha256=P5G4Y04nl5hFwFbJXCkQ-0TMR1L4skLL2IM_FlUjH_c,8364
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
 flock/core/registry/agent_registry.py,sha256=TUClh9e3eA6YzZC1CMTlsTPvQeqb9jYHewi-zPpcWM8,4987
+flock/core/serialization/__init__.py,sha256=j0uw1g-7SOEhD5Ozgc8WpbZNpDWRmu58UOGg4_QTu8U,320
+flock/core/serialization/json_encoder.py,sha256=gAKj2zU_8wQiNvdkby2hksSA4fbPNwTjup_yz1Le1Vw,1229
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
 flock/core/serialization/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
 flock/core/tools/azure_tools.py,sha256=9Bi6IrB5pzBTBhBSxpCVMgx8HBud8nl4gDp8aN0NT6c,17031
@@ -58,7 +60,6 @@ flock/modules/callback/callback_module.py,sha256=volGGgHtY19qj1wHR6m5a_hmXSbV3Ca
 flock/modules/memory/memory_module.py,sha256=dZ30eOFqIlAz0a5IKJMoXgJ-VyPEqApAOX0OQjhGA1I,14733
 flock/modules/memory/memory_parser.py,sha256=FLH7GL8XThvHiCMfX3eQH7Sz-f62fzhAUmO6_gaDI7U,4372
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
-flock/modules/output/output_module.py,sha256=MPs5QV5g5DZQGqR07dS0eBug_TGpkdjX5zTrcrDphq8,7467
 flock/modules/performance/metrics_module.py,sha256=UD9OjY4-zAvauMD7YyDYqE1gyIhzpdr3JkBT8j9knxY,16790
 flock/modules/zep/zep_module.py,sha256=x7JG6O6xnwwum0RETIqKYbA3xzdcvX2aUuns0Cl0c2Q,6014
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
@@ -412,8 +413,8 @@ flock/workflow/activities.py,sha256=yah-lHjMW6_Ww1gt7hMXBis1cJRlcbHx0uLsMB9oNZ0,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.3.18.dist-info/METADATA,sha256=NiwExibjtEysHFQNtBSV0KMH36KFkeU6WFh0VEohXe4,20584
-flock_core-0.3.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.18.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.18.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.18.dist-info/RECORD,,
+flock_core-0.3.21.dist-info/METADATA,sha256=IUx4L0DUqkIx1ZWXBoztYmNDzD85S_zy8PdnPNGXiDU,20620
+flock_core-0.3.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.21.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.21.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.21.dist-info/RECORD,,

flock/modules/output/output_module.py

@@ -1,211 +0,0 @@
-"""Output formatting and display functionality for agents."""
-
-import json
-import os
-from datetime import datetime
-from typing import Any
-
-from pydantic import Field
-
-from flock.core import FlockAgent
-from flock.core.context.context import FlockContext
-from flock.core.flock_module import FlockModule, FlockModuleConfig
-from flock.core.logging.formatters.themed_formatter import (
-    ThemedAgentResultFormatter,
-)
-from flock.core.logging.formatters.themes import OutputTheme
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("module.output")
-
-
-class OutputModuleConfig(FlockModuleConfig):
-    """Configuration for output formatting and display."""
-
-    theme: OutputTheme = Field(
-        default=OutputTheme.afterglow, description="Theme for output formatting"
-    )
-    render_table: bool = Field(
-        default=False, description="Whether to render output as a table"
-    )
-    max_length: int = Field(
-        default=1000, description="Maximum length for displayed output"
-    )
-    wait_for_input: bool = Field(
-        default=False,
-        description="Whether to wait for user input after display",
-    )
-    write_to_file: bool = Field(
-        default=False, description="Whether to save output to file"
-    )
-    output_dir: str = Field(
-        default="output/", description="Directory for saving output files"
-    )
-    truncate_long_values: bool = Field(
-        default=True, description="Whether to truncate long values in display"
-    )
-    show_metadata: bool = Field(
-        default=True, description="Whether to show metadata like timestamps"
-    )
-    format_code_blocks: bool = Field(
-        default=True,
-        description="Whether to apply syntax highlighting to code blocks",
-    )
-    custom_formatters: dict[str, str] = Field(
-        default_factory=dict,
-        description="Custom formatters for specific output types",
-    )
-    no_output: bool = Field(
-        default=False,
-        description="Whether to suppress output",
-    )
-    print_context: bool = Field(
-        default=False,
-        description="Whether to print the context",
-    )
-
-
-class OutputModule(FlockModule):
-    """Module that handles output formatting and display."""
-
-    name: str = "output"
-    config: OutputModuleConfig = Field(
-        default_factory=OutputModuleConfig, description="Output configuration"
-    )
-
-    def __init__(self, name: str, config: OutputModuleConfig):
-        super().__init__(name=name, config=config)
-        if self.config.write_to_file:
-            os.makedirs(self.config.output_dir, exist_ok=True)
-        self._formatter = ThemedAgentResultFormatter(
-            theme=self.config.theme,
-            max_length=self.config.max_length,
-            render_table=self.config.render_table,
-            wait_for_input=self.config.wait_for_input,
-            write_to_file=self.config.write_to_file,
-        )
-
-    def _format_value(self, value: Any, key: str) -> str:
-        """Format a single value based on its type and configuration."""
-        # Check for custom formatter
-        if key in self.config.custom_formatters:
-            formatter_name = self.config.custom_formatters[key]
-            if hasattr(self, f"_format_{formatter_name}"):
-                return getattr(self, f"_format_{formatter_name}")(value)
-
-        # Default formatting based on type
-        if isinstance(value, dict):
-            return self._format_dict(value)
-        elif isinstance(value, list):
-            return self._format_list(value)
-        elif isinstance(value, str) and self.config.format_code_blocks:
-            return self._format_potential_code(value)
-        else:
-            return str(value)
-
-    def _format_dict(self, d: dict[str, Any], indent: int = 0) -> str:
-        """Format a dictionary with proper indentation."""
-        lines = []
-        for k, v in d.items():
-            formatted_value = self._format_value(v, k)
-            if (
-                self.config.truncate_long_values
-                and len(formatted_value) > self.config.max_length
-            ):
-                formatted_value = (
-                    formatted_value[: self.config.max_length] + "..."
-                )
-            lines.append(f"{'  ' * indent}{k}: {formatted_value}")
-        return "\n".join(lines)
-
-    def _format_list(self, lst: list[Any]) -> str:
-        """Format a list with proper indentation."""
-        return "\n".join(f"- {self._format_value(item, '')}" for item in lst)
-
-    def _format_potential_code(self, text: str) -> str:
-        """Format text that might contain code blocks."""
-        import re
-
-        def replace_code_block(match):
-            code = match.group(2)
-            lang = match.group(1) if match.group(1) else ""
-            # Here you could add syntax highlighting
-            return f"```{lang}\n{code}\n```"
-
-        # Replace code blocks with formatted versions
-        text = re.sub(
-            r"```(\w+)?\n(.*?)\n```", replace_code_block, text, flags=re.DOTALL
-        )
-        return text
-
-    def _save_output(self, agent_name: str, result: dict[str, Any]) -> None:
-        """Save output to file if configured."""
-        if not self.config.write_to_file:
-            return
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"{agent_name}_output_{timestamp}.json"
-        filepath = os.path.join(self.config.output_dir, filename)
-
-        output_data = {
-            "agent": agent_name,
-            "timestamp": timestamp,
-            "result": result,
-        }
-
-        if self.config.show_metadata:
-            output_data["metadata"] = {
-                "formatted_at": datetime.now().isoformat(),
-                "theme": self.config.theme.value,
-                "max_length": self.config.max_length,
-            }
-
-        with open(filepath, "w") as f:
-            json.dump(output_data, f, indent=2)
-
-    async def post_evaluate(
-        self,
-        agent: FlockAgent,
-        inputs: dict[str, Any],
-        result: dict[str, Any],
-        context: FlockContext | None = None,
-    ) -> dict[str, Any]:
-        """Format and display the output."""
-        logger.debug("Formatting and displaying output")
-        if self.config.no_output:
-            return result
-        if self.config.print_context:
-            result["context"] = context
-        # Display the result using the formatter
-        self._formatter.display_result(result, agent.name)
-
-        # Save to file if configured
-        self._save_output(agent.name, result)
-
-        return result
-
-    def update_theme(self, new_theme: OutputTheme) -> None:
-        """Update the output theme."""
-        self.config.theme = new_theme
-        self._formatter = ThemedAgentResultFormatter(
-            theme=self.config.theme,
-            max_length=self.config.max_length,
-            render_table=self.config.render_table,
-            wait_for_input=self.config.wait_for_input,
-            write_to_file=self.config.write_to_file,
-        )
-
-    def add_custom_formatter(self, key: str, formatter_name: str) -> None:
-        """Add a custom formatter for a specific output key."""
-        self.config.custom_formatters[key] = formatter_name
-
-    def get_output_files(self) -> list[str]:
-        """Get list of saved output files."""
-        if not self.config.write_to_file:
-            return []
-
-        return [
-            f
-            for f in os.listdir(self.config.output_dir)
-            if f.endswith("_output.json")
-        ]