janito 0.14.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

janito/cli/app.py

@@ -1,182 +0,0 @@
-"""
-Main CLI application for Janito.
-"""
-import sys
-from typing import Optional
-import typer
-from rich.console import Console
-import importlib.metadata
-
-from janito import __version__
-from janito.config import get_config
-from janito.cli.commands import handle_config_commands, validate_parameters
-from janito.cli.agent import handle_query
-from janito.cli.utils import get_stdin_termination_hint
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def main(ctx: typer.Context, 
-         query: Optional[str] = typer.Argument(None, help="Query to send to the claudine agent"),
-         verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode with detailed output"),
-         show_tokens: bool = typer.Option(False, "--show-tokens", "--tokens", help="Show detailed token usage and pricing information"),
-         workspace: Optional[str] = typer.Option(None, "--workspace", "-w", help="Set the workspace directory"),
-         config_str: Optional[str] = typer.Option(None, "--set-config", help="Configuration string in format 'key=value', e.g., 'temperature=0.7' or 'profile=technical'"),
-         show_config: bool = typer.Option(False, "--show-config", help="Show current configuration"),
-         reset_config: bool = typer.Option(False, "--reset-config", help="Reset configuration by removing the config file"),
-         set_api_key: Optional[str] = typer.Option(None, "--set-api-key", help="Set the Anthropic API key globally in the user's home directory"),
-         ask: bool = typer.Option(False, "--ask", help="Enable ask mode which disables tools that perform changes"),
-         trust: bool = typer.Option(False, "--trust", "-t", help="Enable trust mode which suppresses tool outputs for a more concise execution"),
-         no_tools: bool = typer.Option(False, "--no-tools", help="Disable all tools for this session (per-session setting, not saved to config)"),
-         temperature: float = typer.Option(0.0, "--temperature", help="Set the temperature for model generation (0.0 to 1.0)"),
-         profile: Optional[str] = typer.Option(None, "--profile", help="Use a predefined parameter profile (precise, balanced, conversational, creative, technical)"),
-         role: Optional[str] = typer.Option(None, "--role", help="Set the assistant's role (default: 'software engineer')"),
-         system: Optional[str] = typer.Option(None, "--system", "-s", help="Provide custom system instructions, bypassing the default file load method"),
-         version: bool = typer.Option(False, "--version", help="Show the version and exit"),
-         continue_id: Optional[str] = typer.Option(None, "--continue-id", help="Continue a specific conversation with the given ID"),
-         continue_flag: Optional[str] = typer.Option(None, "--continue", "-c", help="Continue a conversation. Can be used as: 1) --continue (to continue most recent), 2) --continue 123 (to continue conversation with ID 123), or 3) --continue \"query\" (to continue most recent with new query)"),
-         history_flag: bool = typer.Option(False, "--history", help="Show a summary of conversations. Use --history for default (20) or --history n to specify count")):
-    """
-    Janito CLI tool. If a query is provided without a command, it will be sent to the claudine agent.
-    """    
-    # Set verbose mode in config
-    get_config().verbose = verbose
-    
-    # Set ask mode in config
-    get_config().ask_mode = ask
-    
-    # Set trust mode in config
-    get_config().trust_mode = trust
-    
-    # Set no-tools mode in config
-    get_config().no_tools = no_tools
-    
-    # Show a message if ask mode is enabled
-    if ask:
-        console.print("[bold yellow]⚠️ Ask Mode enabled:[/bold yellow] 🔒 Tools that perform changes are disabled")
-        
-    # Show a message if trust mode is enabled
-    if trust:
-        console.print("[bold blue]⚡ Trust Mode enabled:[/bold blue] Tool outputs are suppressed for concise execution")
-        
-    # Show a message if no-tools mode is enabled
-    if no_tools:
-        console.print("[bold magenta]🚫 No-Tools Mode enabled:[/bold magenta] All tools are disabled for this session")
-    
-    # Show version and exit if requested
-    if version:
-        console.print(f"🚀 Janito version: {__version__}")
-        sys.exit(0)
-    
-    # Validate temperature
-    validate_parameters(temperature)
-    
-    # Process continue flags before handling other options
-    continue_conversation = None
-    
-    # First, parse continue_flag and continue_id from original sys.argv to avoid typer issues
-    # This is necessary because typer has trouble with quotes in some edge cases
-    try:
-        # Check if --continue or -c is in sys.argv
-        args = sys.argv
-        
-        # Handle the --history flag with optional count parameter
-        history_count_override = None
-        if "--history" in args:
-            history_idx = args.index("--history")
-            history_flag = True
-            
-            # Check if there's a number after --history and it's not another flag
-            if history_idx + 1 < len(args) and not args[history_idx + 1].startswith("-"):
-                try:
-                    # Try to convert to int - if successful, it's a count
-                    history_count_override = int(args[history_idx + 1])
-                except ValueError:
-                    # Not a number, ignore it
-                    pass
-        
-        if "--continue" in args or "-c" in args:
-            continue_idx = args.index("--continue") if "--continue" in args else args.index("-c")
-            
-            # Check if there's at least one argument after --continue
-            if continue_idx + 1 < len(args) and not args[continue_idx + 1].startswith("-"):
-                # If next arg doesn't start with "-", it's our continue value
-                continue_value = args[continue_idx + 1]
-                
-                # Check if continue_value is a numeric ID or a query
-                if continue_value.isdigit():
-                    # It's an ID
-                    continue_conversation = continue_value
-                    
-                    # Check if there's a query after the ID
-                    if continue_idx + 2 < len(args) and not args[continue_idx + 2].startswith("-"):
-                        query = args[continue_idx + 2]
-                else:
-                    # It's a query string for the most recent conversation
-                    continue_conversation = ""  # Empty string means continue most recent
-                    query = continue_value
-                    
-                    if verbose:
-                        console.print(f"[bold blue]🔄 Continuing most recent conversation[/bold blue]")
-                        console.print(f"[dim]📝 Query: {query}[/dim]")
-            else:
-                # --continue with no args means continue most recent conversation
-                continue_conversation = ""
-        
-        # Handle explicit --continue-id if specified (this takes precedence)
-        if "--continue-id" in args:
-            continue_id_idx = args.index("--continue-id")
-            if continue_id_idx + 1 < len(args) and not args[continue_id_idx + 1].startswith("-"):
-                continue_conversation = args[continue_id_idx + 1]
-    except Exception as e:
-        if verbose:
-            console.print(f"[bold yellow]⚠️ Error parsing continue arguments: {str(e)}[/bold yellow]")
-    
-    # Fall back to typer-processed args if our parsing failed
-    if continue_conversation is None:
-        # Handle the --continue-id option
-        if continue_id is not None:
-            continue_conversation = continue_id
-        # Handle the --continue flag option (processed by typer)
-        elif continue_flag is not None:
-            if continue_flag == "":
-                continue_conversation = ""  # Empty string means continue most recent
-            elif continue_flag.isdigit():
-                continue_conversation = continue_flag
-            else:
-                continue_conversation = ""  # Empty string means continue most recent
-                query = continue_flag  # Use the continue_flag as the query
-    
-    # Handle configuration-related commands
-    exit_after_config = handle_config_commands(
-        ctx, 
-        reset_config, 
-        workspace, 
-        show_config, 
-        profile, 
-        role, 
-        set_api_key, 
-        config_str, 
-        query,
-        continue_id,
-        continue_flag,
-        history_flag,
-        history_count_override
-    )
-    
-    if exit_after_config:
-        sys.exit(0)
-    
-    # Handle query if no subcommand was invoked
-    if ctx.invoked_subcommand is None:
-        # If no query provided in command line, read from stdin
-        # Only prompt for stdin if query is still None after processing --continue flag
-        if not query:
-            console.print("[bold blue]📝 No query provided in command line. Reading from stdin...[/bold blue]")
-            console.print(get_stdin_termination_hint())
-            query = sys.stdin.read().strip()
-            
-        # Only proceed if we have a query (either from command line or stdin)
-        if query:
-            handle_query(query, temperature, verbose, show_tokens, continue_conversation, system)

janito/cli/commands/__init__.py

@@ -1,12 +0,0 @@
-"""
-Command handling logic for Janito CLI.
-"""
-from janito.cli.commands.config import handle_config_commands
-from janito.cli.commands.validation import validate_parameters
-from janito.cli.commands.history import handle_history
-
-__all__ = [
-    "handle_config_commands",
-    "validate_parameters",
-    "handle_history",
-]

janito/cli/commands/config.py

@@ -1,242 +0,0 @@
-"""
-Configuration management functions for Janito CLI.
-"""
-import sys
-import os
-from pathlib import Path
-from typing import Optional
-import typer
-from rich.console import Console
-
-from janito.config import get_config, Config
-from janito.cli.commands.workspace import handle_workspace
-from janito.cli.commands.profile import handle_profile, handle_role
-from janito.cli.commands.history import handle_history
-
-console = Console()
-
-def handle_reset_config(reset_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --reset-config parameter.
-    
-    Args:
-        reset_config: Whether to reset the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if reset_config:
-        try:
-            config_path = Path(get_config().workspace_dir) / ".janito" / "config.json"
-            if get_config().reset_config():
-                console.print(f"[bold green]✅ Configuration file removed: {config_path}[/bold green]")
-            else:
-                console.print(f"[bold yellow]⚠️ Configuration file does not exist: {config_path}[/bold yellow]")
-        except Exception as e:
-            console.print(f"[bold red]Error removing configuration file:[/bold red] {str(e)}")
-        
-        # Exit after resetting config if no other operation is requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_show_config(show_config: bool, ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --show-config parameter.
-    
-    Args:
-        show_config: Whether to show the configuration
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if show_config:
-        config = get_config()
-        console.print("[bold blue]⚙️  Current Configuration:[/bold blue]")
-        console.print(f"[bold]📁 Local Configuration File:[/bold] .janito/config.json")
-        console.print(f"[bold]🏠 Global Configuration File:[/bold] {Path.home() / '.janito' / 'config.json'}")
-        
-        # Show API key status
-        api_key_global = Config.get_api_key()
-        api_key_env = os.environ.get("ANTHROPIC_API_KEY")
-        if api_key_global:
-            console.print(f"[bold]🔑 API Key:[/bold] [green]Set in global config[/green]")
-        elif api_key_env:
-            console.print(f"[bold]🔑 API Key:[/bold] [yellow]Set in environment variable[/yellow]")
-        else:
-            console.print(f"[bold]🔑 API Key:[/bold] [red]Not set[/red]")
-            
-        console.print(f"[bold]🔊 Verbose Mode:[/bold] {'Enabled' if config.verbose else 'Disabled'}")
-        console.print(f"[bold]❓ Ask Mode:[/bold] {'Enabled' if config.ask_mode else 'Disabled'}")
-
-        console.print(f"[bold]👤 Role:[/bold] {config.role}")
-        
-        # Show profile information if one is set
-        if config.profile:
-            profile_data = config.get_available_profiles()[config.profile]
-            console.print(f"[bold]📋 Active Profile:[/bold] {config.profile} - {profile_data['description']}")
-        
-        # Show available profiles
-        profiles = config.get_available_profiles()
-        if profiles:
-            console.print("\n[bold blue]📋 Available Parameter Profiles:[/bold blue]")
-            for name, data in profiles.items():
-                console.print(f"[bold]🔹 {name}[/bold] - {data['description']}")
-            
-        # Exit if this was the only operation requested
-        return ctx.invoked_subcommand is None and not query
-    
-    return False
-
-def handle_set_api_key(set_api_key: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-api-key parameter.
-    
-    Args:
-        set_api_key: API key
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if set_api_key is not None:
-        try:
-            Config.set_api_key(set_api_key)
-            console.print(f"[bold green]✅ API key saved to global configuration[/bold green]")
-            console.print(f"[dim]📁 Location: {Path.home() / '.janito' / 'config.json'}[/dim]")
-            
-            # Exit after setting API key if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_set_config(config_str: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --set-config parameter.
-    
-    Args:
-        config_str: Configuration string in format 'key=value'
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if config_str is not None:
-        try:
-            # Parse the config string
-            config_parts = config_str.split("=", 1)
-            if len(config_parts) != 2:
-                console.print(f"[bold red]Error:[/bold red] Invalid configuration format. Use 'key=value' format.")
-                return ctx.invoked_subcommand is None and not query
-                
-            key = config_parts[0].strip()
-            value = config_parts[1].strip()
-            
-            # Remove quotes if present
-            if (value.startswith("'") and value.endswith("'")) or \
-               (value.startswith('"') and value.endswith('"')):
-                value = value[1:-1]
-                
-            if key == "profile":
-                try:
-                    get_config().set_profile(value)
-                    profile_data = get_config().get_available_profiles()[value.lower()]
-                    console.print(f"[bold green]✅ Profile set to '{value.lower()}'[/bold green]")
-                    console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-                except ValueError as e:
-                    console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            elif key == "temperature":
-                try:
-                    temp_value = float(value)
-                    if temp_value < 0.0 or temp_value > 1.0:
-                        console.print("[bold red]Error:[/bold red] Temperature must be between 0.0 and 1.0")
-                        return ctx.invoked_subcommand is None and not query
-                    
-                    get_config().temperature = temp_value
-                    console.print(f"[bold green]✅ Temperature set to {temp_value} and saved to configuration[/bold green]")
-                except ValueError:
-                    console.print(f"[bold red]Error:[/bold red] Invalid temperature value: {value}. Must be a float between 0.0 and 1.0.")
-            # top_k and top_p are now only accessible through profiles
-            elif key == "role":
-                get_config().role = value
-                console.print(f"[bold green]✅ Role set to '{value}' and saved to configuration[/bold green]")
-            else:
-                console.print(f"[bold yellow]Warning:[/bold yellow] Unsupported configuration key: {key}")
-            
-            # Exit after applying config changes if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            
-    return False
-
-def handle_config_commands(
-    ctx: typer.Context,
-    reset_config: bool,
-    workspace: Optional[str],
-    show_config: bool,
-    profile: Optional[str],
-    role: Optional[str],
-    set_api_key: Optional[str],
-    config_str: Optional[str],
-    query: Optional[str],
-    continue_id: Optional[str] = None,
-    continue_flag: Optional[str] = None,
-    history_flag: bool = False,
-    history_count: Optional[int] = None
-) -> bool:
-    """
-    Handle all configuration-related commands.
-    
-    Args:
-        ctx: Typer context
-        reset_config: Whether to reset the configuration
-        workspace: Workspace directory path
-        show_config: Whether to show the configuration
-        profile: Profile name
-        role: Role name
-        set_api_key: API key
-        config_str: Configuration string in format 'key=value'
-        query: Query string
-        continue_id: Optional message ID to continue a specific conversation
-        continue_flag: Optional string that can be empty (flag only) or contain a chat ID
-        history_flag: Whether to show conversation history (--history flag)
-        history_count: Number of history entries to display (value after --history)
-        
-    Returns:
-        bool: True if the program should exit after these operations
-    """
-    # Handle each command and check if we should exit after it
-    if handle_reset_config(reset_config, ctx, query):
-        return True
-        
-    handle_workspace(workspace)
-    
-    if handle_show_config(show_config, ctx, query):
-        return True
-        
-    if handle_profile(profile, ctx, query):
-        return True
-        
-    if handle_role(role, ctx, query):
-        return True
-        
-    if handle_set_api_key(set_api_key, ctx, query):
-        return True
-        
-    if handle_set_config(config_str, ctx, query):
-        return True
-    
-    if handle_history(history_flag, history_count, ctx, query):
-        return True
-        
-    return False

janito/cli/commands/history.py

@@ -1,119 +0,0 @@
-"""
-History management functions for Janito CLI.
-"""
-import sys
-import json
-import datetime
-from pathlib import Path
-from typing import Optional, List, Dict, Any
-import typer
-from rich.console import Console
-from rich.table import Table
-
-from janito.config import get_config
-
-console = Console()
-
-def handle_history(history_flag: bool, history_count: Optional[int], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --history parameter to display conversation history.
-    
-    Args:
-        history_flag: Whether to show history (--history flag)
-        history_count: Number of history entries to display (value after --history)
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    # Check if --history was used
-    if history_flag:
-        try:
-            # If --history is used with a count value passed from app.py, use that
-            # If no count is specified, default to 20
-            count = 20 if history_count is None else history_count
-            
-            # Get the workspace directory
-            workspace_dir = Path(get_config().workspace_dir)
-            janito_dir = workspace_dir / ".janito"
-            messages_dir = janito_dir / "last_messages"
-            
-            if not messages_dir.exists() or not any(messages_dir.iterdir()):
-                console.print("[bold yellow]⚠️ No conversation history found[/bold yellow]")
-                return True  # Always exit after displaying history
-            
-            # Find all message files and sort by timestamp (newest first)
-            message_files = [f for f in messages_dir.iterdir() if f.is_file() and f.suffix == '.json']
-            message_files.sort(key=lambda x: x.stem, reverse=True)
-            
-            # Limit to the requested number of entries
-            message_files = message_files[:count]
-            
-            # Create a table for the history
-            table = Table(title=f"Conversation History (Last {min(count, len(message_files))} Entries)")
-            table.add_column("ID", style="cyan")
-            table.add_column("Date", style="green")
-            table.add_column("Time", style="green")
-            table.add_column("First Query", style="yellow")
-            
-            # Add rows to the table
-            for file in message_files:
-                try:
-                    with open(file, "r", encoding="utf-8") as f:
-                        message_object = json.load(f)
-                    
-                    # Extract message ID and timestamp
-                    message_id = message_object.get("id", file.stem)
-                    
-                    # Parse timestamp
-                    timestamp_str = message_object.get("timestamp")
-                    if timestamp_str:
-                        timestamp = datetime.datetime.fromisoformat(timestamp_str)
-                        date_str = timestamp.strftime("%Y-%m-%d")
-                        time_str = timestamp.strftime("%H:%M:%S")
-                    else:
-                        # Fallback to file name which is a timestamp
-                        timestamp_str = file.stem
-                        date_str = timestamp_str[:8]  # YYYYMMDD
-                        time_str = timestamp_str[8:]  # HHMMSS
-                        
-                        # Format the date and time
-                        if len(date_str) == 8:
-                            date_str = f"{date_str[:4]}-{date_str[4:6]}-{date_str[6:8]}"
-                        if len(time_str) == 6:
-                            time_str = f"{time_str[:2]}:{time_str[2:4]}:{time_str[4:6]}"
-                    
-                    # Extract the first user message
-                    messages = message_object.get("messages", [])
-                    first_query = "N/A"
-                    for msg in messages:
-                        if msg.get("role") == "user":
-                            first_query = msg.get("content", "N/A")
-                            # Truncate long queries
-                            if len(first_query) > 60:
-                                first_query = first_query[:57] + "..."
-                            break
-                    
-                    table.add_row(message_id, date_str, time_str, first_query)
-                except Exception as e:
-                    table.add_row(file.stem, "Error", "Error", f"Failed to parse: {str(e)}")
-            
-            console.print(table)
-            
-            # Display information about how to continue conversations
-            console.print("\n[bold blue]💡 To continue a conversation:[/bold blue]")
-            script_name = "janito"
-            if sys.argv[0].endswith(('janito', 'janito.exe')):
-                console.print(f"  {script_name} --continue <ID> <request>")
-            else:
-                console.print(f"  python -m janito --continue <ID> <request>")
-            
-            # If --history flag is used, always exit regardless of whether a query is provided
-            return True
-                
-        except Exception as e:
-            console.print(f"[bold red]Error displaying history:[/bold red] {str(e)}")
-            return True  # Exit on error
-            
-    return False

janito/cli/commands/profile.py

@@ -1,72 +0,0 @@
-"""
-Profile and role management functions for Janito CLI.
-"""
-import sys
-from typing import Optional
-import typer
-from rich.console import Console
-
-from janito.config import get_config
-
-console = Console()
-
-def handle_profile(profile: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --profile parameter.
-    
-    Args:
-        profile: Profile name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if profile is not None:
-        try:
-            # Apply profile without saving to config
-            config = get_config()
-            profile_data = config.get_available_profiles()[profile.lower()]
-            
-            # Set values directly without saving
-            config._temperature = profile_data["temperature"]
-            config._profile = profile.lower()
-            
-            console.print(f"[bold green]✅ Profile '{profile.lower()}' applied for this session only[/bold green]")
-            console.print(f"[dim]📝 Description: {profile_data['description']}[/dim]")
-            
-            # Exit after applying profile if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False
-
-def handle_role(role: Optional[str], ctx: typer.Context, query: Optional[str]) -> bool:
-    """
-    Handle the --role parameter.
-    
-    Args:
-        role: Role name
-        ctx: Typer context
-        query: Query string
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if role is not None:
-        try:
-            # Set role directly without saving to config
-            config = get_config()
-            config._role = role
-            
-            console.print(f"[bold green]✅ Role '{role}' applied for this session only[/bold green]")
-            
-            # Exit after applying role if no other operation is requested
-            return ctx.invoked_subcommand is None and not query
-        except Exception as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False

janito/cli/commands/validation.py

@@ -1,24 +0,0 @@
-"""
-Parameter validation functions for Janito CLI.
-"""
-import sys
-from rich.console import Console
-
-console = Console()
-
-def validate_parameters(temperature: float) -> None:
-    """
-    Validate temperature parameter.
-    
-    Args:
-        temperature: Temperature value for model generation
-    """
-    try:
-        if temperature < 0.0 or temperature > 1.0:
-            raise ValueError("Temperature must be between 0.0 and 1.0")
-            
-        # We'll use this value directly in the agent initialization but we don't save it to config
-        # Temperature display is hidden
-    except ValueError as e:
-        console.print(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)

janito/cli/commands/workspace.py

@@ -1,31 +0,0 @@
-"""
-Workspace management functions for Janito CLI.
-"""
-import sys
-from typing import Optional
-from rich.console import Console
-
-from janito.config import get_config
-
-console = Console()
-
-def handle_workspace(workspace: Optional[str]) -> bool:
-    """
-    Handle the --workspace parameter.
-    
-    Args:
-        workspace: Workspace directory path
-        
-    Returns:
-        bool: True if the program should exit after this operation
-    """
-    if workspace:
-        try:
-            console.print(f"[bold]📂 Setting workspace directory to: {workspace}[/bold]")
-            get_config().workspace_dir = workspace
-            console.print(f"[bold green]✅ Workspace directory set to: {get_config().workspace_dir}[/bold green]")
-        except ValueError as e:
-            console.print(f"[bold red]Error:[/bold red] {str(e)}")
-            sys.exit(1)
-    
-    return False