yaicli 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.2.0"
+version = "0.3.0"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"

yaicli/api.py

@@ -8,33 +8,18 @@ from rich.console import Console
 from yaicli.const import (
     DEFAULT_BASE_URL,
     DEFAULT_COMPLETION_PATH,
-    DEFAULT_MAX_TOKENS,
     DEFAULT_MODEL,
-    DEFAULT_TEMPERATURE,
-    DEFAULT_TIMEOUT,
-    DEFAULT_TOP_P,
     EventTypeEnum,
 )
 
 
 def parse_stream_line(line: Union[bytes, str], console: Console, verbose: bool) -> Optional[dict]:
     """(Helper Function) Parse a single line from the SSE stream response."""
-    line_str: str
-    if isinstance(line, bytes):
-        try:
-            line_str = line.decode("utf-8")
-        except UnicodeDecodeError:
-            if verbose:
-                console.print(f"Warning: Could not decode stream line bytes: {line!r}", style="yellow")
-            return None
-    elif isinstance(line, str):
-        line_str = line
-    else:
-        # Handle unexpected line types
+    if not isinstance(line, (bytes, str)):
         if verbose:
-            console.print(f"Warning: Received unexpected line type: {type(line)}", style="yellow")
+            console.print(f"Warning: Received non-string/bytes line: {line!r}", style="yellow")
         return None
-
+    line_str: str = line.decode("utf-8") if isinstance(line, bytes) else line
     line_str = line_str.strip()
     if not line_str or not line_str.startswith("data: "):
         return None
@@ -69,8 +54,8 @@ class ApiClient:
         self.completion_path = str(config.get("COMPLETION_PATH", DEFAULT_COMPLETION_PATH))
         self.api_key = str(config.get("API_KEY", ""))
         self.model = str(config.get("MODEL", DEFAULT_MODEL))
-        self.timeout = self.config.get("TIMEOUT", DEFAULT_TIMEOUT)
-        self.client = client or httpx.Client(timeout=self.config.get("TIMEOUT", DEFAULT_TIMEOUT))
+        self.timeout = self.config["TIMEOUT"]
+        self.client = client or httpx.Client(timeout=self.config["TIMEOUT"])
 
     def _prepare_request_body(self, messages: List[Dict[str, str]], stream: bool) -> Dict[str, Any]:
         """Prepare the common request body for API calls."""
@@ -78,9 +63,12 @@ class ApiClient:
             "messages": messages,
             "model": self.model,
             "stream": stream,
-            "temperature": self.config.get("TEMPERATURE", DEFAULT_TEMPERATURE),
-            "top_p": self.config.get("TOP_P", DEFAULT_TOP_P),
-            "max_tokens": self.config.get("MAX_TOKENS", DEFAULT_MAX_TOKENS),
+            "temperature": self.config["TEMPERATURE"],
+            "top_p": self.config["TOP_P"],
+            "max_tokens": self.config[
+                "MAX_TOKENS"
+            ],  # Openai: This value is now deprecated in favor of max_completion_tokens
+            "max_completion_tokens": self.config["MAX_TOKENS"],
         }
 
     def _handle_api_error(self, e: httpx.HTTPError) -> None:
@@ -190,7 +178,7 @@ class ApiClient:
         """Process a single chunk from the stream and yield events with updated reasoning state.
 
         Args:
-            parsed_data: The parsed JSON data from a stream line
+            parsed_data: The parsed JSON data from a streamline
             in_reasoning: Whether we're currently in a reasoning state
 
         Yields:
@@ -273,7 +261,7 @@ class ApiClient:
                     yield self._handle_http_error(e)
                     return
 
-                # Process the stream line by line
+                # Process the streamline by line
                 for line in response.iter_lines():
                     parsed_data = parse_stream_line(line, self.console, self.verbose)
                     if parsed_data is None:
@@ -315,7 +303,7 @@ class ApiClient:
         # reasoning_content: deepseek/infi-ai
         # reasoning: openrouter
         # <think> block implementation not in here
-        for key in ("reasoning_content", "reasoning", "metadata"):
+        for key in ("reasoning_content", "reasoning"):
             # Check if the key exists and its value is a non-empty string
             value = delta.get(key)
             if isinstance(value, str) and value:

yaicli/chat_manager.py

@@ -3,17 +3,30 @@ import time
 from abc import ABC, abstractmethod
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, Dict, List, Optional, TypedDict, Union
 
-from rich import get_console
 from rich.console import Console
 
-from yaicli.config import Config
+from yaicli.config import Config, cfg
+from yaicli.console import get_console
+from yaicli.utils import option_callback
+
+
+class ChatFileInfo(TypedDict):
+    """Chat info, parse chat filename and store metadata"""
+
+    index: int
+    path: str
+    title: str
+    date: str
+    timestamp: int
 
 
 class ChatsMap(TypedDict):
-    title: Dict[str, dict]
-    index: Dict[int, dict]
+    """Chat info cache for chat manager"""
+
+    title: Dict[str, ChatFileInfo]
+    index: Dict[int, ChatFileInfo]
 
 
 class ChatManager(ABC):
@@ -30,7 +43,7 @@ class ChatManager(ABC):
         pass
 
     @abstractmethod
-    def list_chats(self) -> List[Dict[str, Any]]:
+    def list_chats(self) -> List[ChatFileInfo]:
         """List all saved chats and return the chat list"""
         pass
 
@@ -40,12 +53,12 @@ class ChatManager(ABC):
         pass
 
     @abstractmethod
-    def load_chat_by_index(self, index: int) -> Dict[str, Any]:
+    def load_chat_by_index(self, index: int) -> Union[ChatFileInfo, Dict]:
         """Load a chat by index and return the chat data"""
         pass
 
     @abstractmethod
-    def load_chat_by_title(self, title: str) -> Dict[str, Any]:
+    def load_chat_by_title(self, title: str) -> Union[ChatFileInfo, Dict]:
         """Load a chat by title and return the chat data"""
         pass
 
@@ -63,13 +76,14 @@ class ChatManager(ABC):
 class FileChatManager(ChatManager):
     """File system based chat manager implementation"""
 
-    def __init__(self, config: Config, console: Optional[Console] = None):
-        self.config = config
-        self.chat_dir = Path(self.config["CHAT_HISTORY_DIR"])
-        self.chat_dir.mkdir(parents=True, exist_ok=True)
-        self.max_saved_chats = self.config["MAX_SAVED_CHATS"]
+    console: Console = get_console()
+    config: Config = cfg
+    chat_dir = Path(config["CHAT_HISTORY_DIR"])
+    max_saved_chats = config["MAX_SAVED_CHATS"]
+    chat_dir.mkdir(parents=True, exist_ok=True)
+
+    def __init__(self):
         self._chats_map: Optional[ChatsMap] = None  # Cache for chat map
-        self.console = console or get_console()
 
     @property
     def chats_map(self) -> ChatsMap:
@@ -78,6 +92,18 @@ class FileChatManager(ChatManager):
             self._load_chats()
         return self._chats_map or {"index": {}, "title": {}}
 
+    @classmethod
+    @option_callback
+    def print_list_option(cls, _: Any):
+        """Print the list of chats"""
+        cls.console.print("Finding Chats...")
+        c = -1
+        for c, file in enumerate(sorted(cls.chat_dir.glob("*.json"), key=lambda f: f.stat().st_mtime)):
+            info: ChatFileInfo = cls._parse_filename(file, c + 1)
+            cls.console.print(f"{c + 1}. {info['title']} ({info['date']})")
+        if c == -1:
+            cls.console.print("No chats found", style="dim")
+
     def make_chat_title(self, prompt: Optional[str] = None) -> str:
         """Make a chat title from a given full prompt"""
         if prompt:
@@ -93,7 +119,8 @@ class FileChatManager(ChatManager):
         """Force refresh the chat list from disk"""
         self._load_chats()
 
-    def _parse_filename(self, chat_file: Path, index: int) -> Dict[str, Any]:
+    @staticmethod
+    def _parse_filename(chat_file: Path, index: int) -> ChatFileInfo:
         """Parse a chat filename and extract metadata"""
         # filename: "20250421-214005-title-meaning of life"
         filename = chat_file.stem
@@ -155,7 +182,7 @@ class FileChatManager(ChatManager):
 
         self._chats_map = chats_map
 
-    def list_chats(self) -> List[Dict[str, Any]]:
+    def list_chats(self) -> List[ChatFileInfo]:
         """List all saved chats and return the chat list"""
         return list(self.chats_map["index"].values())
 
@@ -203,7 +230,7 @@ class FileChatManager(ChatManager):
             self.console.print(f"Error saving chat '{save_title}': {e}", style="dim")
             return ""
 
-    def _load_chat_data(self, chat_info: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    def _load_chat_data(self, chat_info: Optional[ChatFileInfo]) -> Union[ChatFileInfo, Dict]:
         """Common method to load chat data from a chat info dict"""
         if not chat_info:
             return {}
@@ -228,14 +255,14 @@ class FileChatManager(ChatManager):
             self.console.print(f"Error loading chat from {chat_info['path']}: {e}", style="dim")
             return {}
 
-    def load_chat_by_index(self, index: int) -> Dict[str, Any]:
+    def load_chat_by_index(self, index: int) -> Union[ChatFileInfo, Dict]:
         """Load a chat by index and return the chat data"""
         if not self.validate_chat_index(index):
             return {}
         chat_info = self.chats_map.get("index", {}).get(index)
         return self._load_chat_data(chat_info)
 
-    def load_chat_by_title(self, title: str) -> Dict[str, Any]:
+    def load_chat_by_title(self, title: str) -> Union[ChatFileInfo, Dict]:
         """Load a chat by title and return the chat data"""
         chat_info = self.chats_map.get("title", {}).get(title)
         return self._load_chat_data(chat_info)

yaicli/cli.py

@@ -4,22 +4,22 @@ import time
 import traceback
 from os.path import devnull
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import List, Literal, Optional, Tuple
 
 import typer
 from prompt_toolkit import PromptSession, prompt
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.keys import Keys
-from rich import get_console
 from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.panel import Panel
 from rich.prompt import Prompt
 
 from yaicli.api import ApiClient
-from yaicli.chat_manager import ChatManager, FileChatManager
-from yaicli.config import CONFIG_PATH, Config
+from yaicli.chat_manager import ChatFileInfo, ChatManager, FileChatManager
+from yaicli.config import CONFIG_PATH, Config, cfg
+from yaicli.console import get_console
 from yaicli.const import (
     CHAT_MODE,
     CMD_CLEAR,
@@ -33,14 +33,14 @@ from yaicli.const import (
     DEFAULT_CODE_THEME,
     DEFAULT_INTERACTIVE_ROUND,
     DEFAULT_OS_NAME,
-    DEFAULT_PROMPT,
     DEFAULT_SHELL_NAME,
     EXEC_MODE,
-    SHELL_PROMPT,
     TEMP_MODE,
+    DefaultRoleNames,
 )
 from yaicli.history import LimitedFileHistory
 from yaicli.printer import Printer
+from yaicli.roles import RoleManager
 from yaicli.utils import detect_os, detect_shell, filter_command
 
 
@@ -54,14 +54,26 @@ class CLI:
         api_client: Optional[ApiClient] = None,
         printer: Optional[Printer] = None,
         chat_manager: Optional[ChatManager] = None,
+        role: Optional[str] = None,
     ):
+        # General settings
         self.verbose = verbose
         self.stdin = stdin
         self.console = get_console()
         self.bindings = KeyBindings()
-        self.config: Config = Config(self.console)
+        self.config: Config = cfg
         self.current_mode: str = TEMP_MODE
+        self.role: str = role or DefaultRoleNames.DEFAULT.value
 
+        # Initialize role manager
+        self.role_manager = RoleManager()
+
+        # Validate role
+        if not self.role_manager.role_exists(self.role):
+            self.console.print(f"Role '{self.role}' not found, using default role.", style="yellow")
+            self.role = DefaultRoleNames.DEFAULT.value
+
+        # Interactive chat mode settings
         self.history = []
         self.interactive_max_history = self.config.get("INTERACTIVE_MAX_HISTORY", DEFAULT_INTERACTIVE_ROUND)
         self.chat_title = None
@@ -72,8 +84,8 @@ class CLI:
         self.chat_history_dir = Path(self.config["CHAT_HISTORY_DIR"])
         self.chat_history_dir.mkdir(parents=True, exist_ok=True)
 
-        # Initialize session manager
-        self.chat_manager = chat_manager or FileChatManager(self.config)
+        # Initialize chat manager
+        self.chat_manager = chat_manager or FileChatManager()
 
         # Detect OS and Shell if set to auto
         if self.config.get("OS_NAME") == DEFAULT_OS_NAME:
@@ -87,10 +99,11 @@ class CLI:
             for key, value in self.config.items():
                 display_value = "****" if key == "API_KEY" and value else value
                 self.console.print(f"  {key:<17}: {display_value}")
+            self.console.print(f"Current role: {self.role}")
             self.console.print(Markdown("---", code_theme=self.config.get("CODE_THEME", DEFAULT_CODE_THEME)))
 
         self.api_client = api_client or ApiClient(self.config, self.console, self.verbose)
-        self.printer = printer or Printer(self.config, self.console, self.verbose)
+        self.printer = printer or Printer(self.config, self.console, self.verbose, markdown=True)
 
         _origin_stderr = None
         if not sys.stdin.isatty():
@@ -110,13 +123,25 @@ class CLI:
         return [("class:qmark", f" {mode_icon} "), ("class:prompt", "> ")]
 
     def _check_history_len(self) -> None:
-        """Check history length and remove oldest messages if necessary"""
+        """Check history length and remove the oldest messages if necessary"""
         target_len = self.interactive_max_history * 2
         if len(self.history) > target_len:
             self.history = self.history[-target_len:]
             if self.verbose:
                 self.console.print(f"History trimmed to {target_len} messages.", style="dim")
 
+    # ------------------- Role Command Methods -------------------
+    def set_role(self, role: str) -> None:
+        """Set the current role for the assistant"""
+        if not self.role_manager.role_exists(role):
+            self.console.print(f"Role '{role}' not found.", style="bold red")
+            return
+
+        self.role = role
+        if self.role == DefaultRoleNames.CODER:
+            self.printer = Printer(self.config, self.console, self.verbose, content_markdown=False)
+
+    # ------------------- Chat Command Methods -------------------
     def _save_chat(self, title: Optional[str] = None) -> None:
         """Save current chat history to a file using session manager."""
         saved_title = self.chat_manager.save_chat(self.history, title)
@@ -139,7 +164,7 @@ class CLI:
 
     def _list_chats(self) -> None:
         """List all saved chat sessions using session manager."""
-        chats = self.chat_manager.list_chats()
+        chats: list[ChatFileInfo] = self.chat_manager.list_chats()
 
         if not chats:
             self.console.print("No saved chats found.", style="yellow")
@@ -199,6 +224,7 @@ class CLI:
             self.console.print(f"Failed to delete chat: {chat_data['title']}", style="bold red")
             return False
 
+    # ------------------- Special commands -------------------
     def _handle_special_commands(self, user_input: str) -> Optional[bool]:
         """Handle special command return: True-continue loop, False-exit loop, None-non-special command"""
         command = user_input.lower().strip()
@@ -266,8 +292,6 @@ class CLI:
                 new_mode = parts[1]
                 if self.current_mode != new_mode:
                     self.current_mode = new_mode
-                    mode_name = "Chat" if self.current_mode == CHAT_MODE else "Exec"
-                    self.console.print(f"Switched to [bold yellow]{mode_name}[/bold yellow] mode")
                 else:
                     self.console.print(f"Already in {self.current_mode} mode.", style="yellow")
             else:
@@ -316,21 +340,24 @@ class CLI:
         elif _input != "e":
             self.console.print("Execution cancelled.", style="yellow")
 
+    # ------------------- LLM Methods -------------------
     def get_system_prompt(self) -> str:
-        """Return system prompt for current mode"""
-        prompt_template = SHELL_PROMPT if self.current_mode == EXEC_MODE else DEFAULT_PROMPT
-        stdin = f"\n\nSTDIN\n{self.stdin}" if self.stdin else ""
-        if self.verbose and stdin:
-            self.console.print("Added STDIN to prompt", style="dim")
-        return prompt_template.format(_os=self.config["OS_NAME"], _shell=self.config["SHELL_NAME"]) + stdin
+        """Get the system prompt based on current role and mode"""
+        # Use the role manager to get the system prompt
+        return self.role_manager.get_system_prompt(self.role)
 
     def _build_messages(self, user_input: str) -> List[dict]:
-        """Build the list of messages for the API call."""
-        return [
-            {"role": "system", "content": self.get_system_prompt()},
-            *self.history,
-            {"role": "user", "content": user_input},
-        ]
+        """Build message list for LLM API"""
+        # Create the message list
+        messages = [{"role": "system", "content": self.get_system_prompt()}]
+
+        # Add previous conversation if available
+        for msg in self.history:
+            messages.append(msg)
+
+        # Add user input
+        messages.append({"role": "user", "content": user_input})
+        return messages
 
     def _handle_llm_response(self, user_input: str) -> Optional[str]:
         """Get response from API (streaming or normal) and print it.
@@ -343,16 +370,16 @@ class CLI:
             Optional[str]: The assistant's response content or None if an error occurred.
         """
         messages = self._build_messages(user_input)
-        content = None
-        reasoning = None
-
+        if self.verbose:
+            self.console.print(messages)
+        is_code_mode = self.role == DefaultRoleNames.CODER
         try:
-            if self.config.get("STREAM", True):
+            if self.config["STREAM"]:
                 stream_iterator = self.api_client.stream_completion(messages)
-                content, reasoning = self.printer.display_stream(stream_iterator)
+                content, reasoning = self.printer.display_stream(stream_iterator, not is_code_mode)
             else:
                 content, reasoning = self.api_client.completion(messages)
-                self.printer.display_normal(content, reasoning)
+                self.printer.display_normal(content, reasoning, not is_code_mode)
 
             if content is not None:
                 # Add only the content (not reasoning) to history
@@ -382,6 +409,7 @@ class CLI:
             self._confirm_and_execute(content)
         return True
 
+    # ------------------- REPL Methods -------------------
     def _print_welcome_message(self) -> None:
         """Prints the initial welcome banner and instructions."""
         self.console.print(
@@ -446,21 +474,6 @@ class CLI:
 
         self.console.print("\nExiting YAICLI... Goodbye!", style="bold green")
 
-    def _run_once(self, prompt_arg: str, is_shell_mode: bool) -> None:
-        """Run a single command (non-interactive)."""
-        self.current_mode = EXEC_MODE if is_shell_mode else TEMP_MODE
-        if not self.config.get("API_KEY"):
-            self.console.print("[bold red]Error:[/bold red] API key not found.")
-            raise typer.Exit(code=1)
-
-        content = self._handle_llm_response(prompt_arg)
-
-        if content is None:
-            raise typer.Exit(code=1)
-
-        if is_shell_mode:
-            self._confirm_and_execute(content)
-
     def prepare_chat_loop(self) -> None:
         """Setup key bindings and history for interactive modes."""
         self._setup_key_bindings()
@@ -477,6 +490,7 @@ class CLI:
             self.session = PromptSession(key_bindings=self.bindings)
         if self.chat_title:
             chat_info = self.chat_manager.load_chat_by_title(self.chat_title)
+            self.is_temp_session = False
             self.history = chat_info.get("history", [])
 
     def _setup_key_bindings(self) -> None:
@@ -486,29 +500,48 @@ class CLI:
         def _(event: KeyPressEvent) -> None:
             self.current_mode = EXEC_MODE if self.current_mode == CHAT_MODE else CHAT_MODE
 
-    def run(self, chat: bool, shell: bool, prompt: Optional[str]) -> None:
-        """Main entry point to run the CLI (REPL or single command)."""
-        if chat:
-            if not self.config.get("API_KEY"):
-                self.console.print("[bold red]Error:[/bold red] API key not found. Cannot start chat mode.")
-                return
-            self.current_mode = CHAT_MODE
+    def _run_once(self, input: str, shell: bool) -> None:
+        """Run a single command (non-interactive)."""
+        self.current_mode = EXEC_MODE if shell else TEMP_MODE
+        if not self.config.get("API_KEY"):
+            self.console.print("[bold red]Error:[/bold red] API key not found.")
+            raise typer.Exit(code=1)
 
-            # Only set chat start time and title if a prompt is provided
-            if prompt:
-                self.chat_start_time = int(time.time())
-                self.chat_title = self.chat_manager.make_chat_title(prompt)
-                self.console.print(f"Chat title: [bold]{self.chat_title}[/bold]")
-                self.is_temp_session = False
-            else:
-                # Mark as temporary session if no prompt
-                self.is_temp_session = True
-                self.console.print(
-                    "Starting a temporary chat session (will not be saved automatically)", style="yellow"
-                )
+        content = self._handle_llm_response(input)
 
+        if content is None:
+            raise typer.Exit(code=1)
+
+        if shell:
+            self._confirm_and_execute(content)
+
+    # ------------------- Main Entry Point -------------------
+    def run(
+        self,
+        chat: bool,
+        shell: bool,
+        input: Optional[str],
+        role: Optional[str | Literal[DefaultRoleNames.DEFAULT]] = None,
+    ) -> None:
+        """Run the CLI in the appropriate mode with the selected role."""
+        self.set_role(role or self.role)
+
+        # Now handle normal operation
+        if shell:
+            # Set mode to shell
+            self.role = DefaultRoleNames.SHELL
+            if input:
+                self._run_once(input, shell=True)
+            else:
+                self.console.print("No prompt provided for shell mode.", style="yellow")
+        elif chat:
+            # Start interactive chat mode
+            self.current_mode = CHAT_MODE
+            self.chat_title = input if input else None
+            self.prepare_chat_loop()
             self._run_repl()
-        elif prompt:
-            self._run_once(prompt, shell)
+        elif input:
+            # Run once with the given prompt
+            self._run_once(input, shell=False)
         else:
             self.console.print("No chat or prompt provided. Exiting.")

yaicli/config.py

@@ -1,4 +1,5 @@
 import configparser
+from functools import lru_cache
 from os import getenv
 from typing import Optional
 
@@ -10,6 +11,7 @@ from yaicli.const import (
     DEFAULT_CHAT_HISTORY_DIR,
     DEFAULT_CONFIG_INI,
     DEFAULT_CONFIG_MAP,
+    DEFAULT_JUSTIFY,
     DEFAULT_MAX_SAVED_CHATS,
 )
 from yaicli.utils import str2bool
@@ -36,6 +38,7 @@ class Config(dict):
     def __init__(self, console: Optional[Console] = None):
         """Initializes and loads the configuration."""
         self.console = console or get_console()
+
         super().__init__()
         self.reload()
 
@@ -73,6 +76,8 @@ class Config(dict):
                 f.write(f"\nCHAT_HISTORY_DIR={DEFAULT_CHAT_HISTORY_DIR}\n")
             if "MAX_SAVED_CHATS" not in config_content.strip():  # Check for empty lines
                 f.write(f"\nMAX_SAVED_CHATS={DEFAULT_MAX_SAVED_CHATS}\n")
+            if "JUSTIFY" not in config_content.strip():
+                f.write(f"\nJUSTIFY={DEFAULT_JUSTIFY}\n")
 
     def _load_from_file(self) -> None:
         """Load configuration from the config file.
@@ -80,7 +85,7 @@ class Config(dict):
         Creates default config file if it doesn't exist.
         """
         if not CONFIG_PATH.exists():
-            self.console.print("Creating default configuration file.", style="bold yellow")
+            self.console.print("Creating default configuration file.", style="bold yellow", justify=self.get("JUSTIFY"))
             CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
             with open(CONFIG_PATH, "w", encoding="utf-8") as f:
                 f.write(DEFAULT_CONFIG_INI)
@@ -135,6 +140,7 @@ class Config(dict):
                     f"[yellow]Warning:[/yellow] Invalid value '{raw_value}' for '{key}'. "
                     f"Expected type '{target_type.__name__}'. Using default value '{default_values_str[key]}'. Error: {e}",
                     style="dim",
+                    justify=self.get("JUSTIFY"),
                 )
                 # Fallback to default string value if conversion fails
                 try:
@@ -147,7 +153,17 @@ class Config(dict):
                     self.console.print(
                         f"[red]Error:[/red] Could not convert default value for '{key}'. Using raw value.",
                         style="error",
+                        justify=self.get("JUSTIFY"),
                     )
                     converted_value = raw_value  # Or assign a hardcoded safe default
 
             self[key] = converted_value
+
+
+@lru_cache(maxsize=1)
+def get_config() -> Config:
+    """Get the configuration singleton"""
+    return Config()
+
+
+cfg = get_config()