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

yaicli/cli.py

@@ -1,40 +1,46 @@
 import subprocess
 import sys
+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.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,
+    CMD_DELETE_CHAT,
     CMD_EXIT,
     CMD_HISTORY,
+    CMD_LIST_CHATS,
+    CMD_LOAD_CHAT,
     CMD_MODE,
+    CMD_SAVE_CHAT,
     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
 
 
@@ -42,15 +48,44 @@ class CLI:
     HISTORY_FILE = Path("~/.yaicli_history").expanduser()
 
     def __init__(
-        self, verbose: bool = False, api_client: Optional[ApiClient] = None, printer: Optional[Printer] = None
+        self,
+        verbose: bool = False,
+        stdin: Optional[str] = None,
+        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
+        self.chat_start_time = None
+        self.is_temp_session = True
+
+        # Get and create chat history directory from configuration
+        self.chat_history_dir = Path(self.config["CHAT_HISTORY_DIR"])
+        self.chat_history_dir.mkdir(parents=True, exist_ok=True)
+
+        # 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:
@@ -63,11 +98,12 @@ class CLI:
             self.console.print(f"Config file path: {CONFIG_PATH}")
             for key, value in self.config.items():
                 display_value = "****" if key == "API_KEY" and value else value
-                self.console.print(f"  {key:<16}: {display_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():
@@ -77,20 +113,118 @@ class CLI:
             self.session = PromptSession(key_bindings=self.bindings)
         finally:
             if _origin_stderr:
+                sys.stderr.flush()
                 sys.stderr.close()
                 sys.stderr = _origin_stderr
 
     def get_prompt_tokens(self) -> List[Tuple[str, str]]:
         """Return prompt tokens for current mode"""
-        qmark = "💬" if self.current_mode == CHAT_MODE else "🚀" if self.current_mode == EXEC_MODE else "📝"
-        return [("class:qmark", f" {qmark} "), ("class:prompt", "> ")]
+        mode_icon = "💬" if self.current_mode == CHAT_MODE else "🚀" if self.current_mode == EXEC_MODE else "📝"
+        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)
+
+        if not saved_title:
+            self.console.print("Failed to save chat.", style="bold red")
+            return
+
+        # Session list will be refreshed automatically by the save method
+        self.console.print(f"Chat saved as: {saved_title}", style="bold green")
+
+        # If this was a temporary session, mark it as non-temporary now that it's saved
+        if self.is_temp_session:
+            self.is_temp_session = False
+            self.chat_title = saved_title
+            self.chat_start_time = int(time.time())
+            self.console.print(
+                "Session is now marked as persistent and will be auto-saved on exit.", style="bold green"
+            )
+
+    def _list_chats(self) -> None:
+        """List all saved chat sessions using session manager."""
+        chats: list[ChatFileInfo] = self.chat_manager.list_chats()
+
+        if not chats:
+            self.console.print("No saved chats found.", style="yellow")
+            return
+
+        self.console.print("Saved Chats:", style="bold underline")
+        for chat in chats:
+            index = chat["index"]
+            title = chat["title"]
+            date = chat.get("date", "")
+
+            if date:
+                self.console.print(f"[dim]{index}.[/dim] [bold blue]{title}[/bold blue] - {date}")
+            else:
+                self.console.print(f"[dim]{index}.[/dim] [bold blue]{title}[/bold blue]")
+
+    def _refresh_chats(self) -> None:
+        """Force refresh the chat list."""
+        self.chat_manager.refresh_chats()
 
+    def _load_chat_by_index(self, index: int) -> bool:
+        """Load a chat session by its index using session manager."""
+        if not self.chat_manager.validate_chat_index(index):
+            self.console.print("Invalid chat index.", style="bold red")
+            return False
+
+        chat_data = self.chat_manager.load_chat_by_index(index)
+
+        if not chat_data:
+            self.console.print("Invalid chat index or chat not found.", style="bold red")
+            return False
+
+        self.history = chat_data.get("history", [])
+        self.chat_title = chat_data.get("title")
+        self.chat_start_time = chat_data.get("timestamp", int(time.time()))
+        self.is_temp_session = False
+
+        self.console.print(f"Loaded chat: {self.chat_title}", style="bold green")
+        return True
+
+    def _delete_chat_by_index(self, index: int) -> bool:
+        """Delete a chat session by its index using session manager."""
+        if not self.chat_manager.validate_chat_index(index):
+            self.console.print("Invalid chat index.", style="bold red")
+            return False
+
+        chat_data = self.chat_manager.load_chat_by_index(index)
+
+        if not chat_data:
+            self.console.print("Invalid chat index or chat not found.", style="bold red")
+            return False
+
+        if self.chat_manager.delete_chat(index):
+            self.console.print(f"Deleted chat: {chat_data['title']}", style="bold green")
+            return True
+        else:
+            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()
@@ -105,17 +239,52 @@ class CLI:
                 self.console.print("History is empty.", style="yellow")
             else:
                 self.console.print("Chat History:", style="bold underline")
-                code_theme = self.config.get("CODE_THEME", "monokai")
                 for i in range(0, len(self.history), 2):
                     user_msg = self.history[i]
                     assistant_msg = self.history[i + 1] if (i + 1) < len(self.history) else None
                     self.console.print(f"[dim]{i // 2 + 1}[/dim] [bold blue]User:[/bold blue] {user_msg['content']}")
                     if assistant_msg:
-                        md = Markdown(assistant_msg["content"], code_theme=code_theme)
+                        md = Markdown(assistant_msg["content"], code_theme=self.config["CODE_THEME"])
                         padded_md = Padding(md, (0, 0, 0, 4))
                         self.console.print("    Assistant:", style="bold green")
                         self.console.print(padded_md)
             return True
+
+        # Handle /save command - optional title parameter
+        if command.startswith(CMD_SAVE_CHAT):
+            parts = command.split(maxsplit=1)
+            title = parts[1] if len(parts) > 1 else self.chat_title
+            self._save_chat(title)
+            return True
+
+        # Handle /load command - requires index parameter
+        if command.startswith(CMD_LOAD_CHAT):
+            parts = command.split(maxsplit=1)
+            if len(parts) == 2 and parts[1].isdigit():
+                # Try to parse as an index first
+                index = int(parts[1])
+                self._load_chat_by_index(index=index)
+            else:
+                self.console.print(f"Usage: {CMD_LOAD_CHAT} <index>", style="yellow")
+                self._list_chats()
+            return True
+
+        # Handle /delete command - requires index parameter
+        if command.startswith(CMD_DELETE_CHAT):
+            parts = command.split(maxsplit=1)
+            if len(parts) == 2 and parts[1].isdigit():
+                index = int(parts[1])
+                self._delete_chat_by_index(index=index)
+            else:
+                self.console.print(f"Usage: {CMD_DELETE_CHAT} <index>", style="yellow")
+                self._list_chats()
+            return True
+
+        # Handle /list command to list saved chats
+        if command == CMD_LIST_CHATS:
+            self._list_chats()
+            return True
+
         # Handle /mode command
         if command.startswith(CMD_MODE):
             parts = command.split(maxsplit=1)
@@ -123,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:
@@ -173,20 +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
-        return prompt_template.format(
-            _os=self.config.get("OS_NAME", "Unknown OS"), _shell=self.config.get("SHELL_NAME", "Unknown Shell")
-        )
+        """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.
@@ -199,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
@@ -238,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(
@@ -251,9 +423,25 @@ class CLI:
             style="bold cyan",
         )
         self.console.print("Welcome to YAICLI!", style="bold")
+
+        # Display session type
+        if self.is_temp_session:
+            self.console.print("Current: [bold yellow]Temporary Session[/bold yellow] (use /save to make persistent)")
+        else:
+            self.console.print(
+                f"Current: [bold green]Persistent Session[/bold green]{f': {self.chat_title}' if self.chat_title else ''}"
+            )
+
         self.console.print("Press [bold yellow]TAB[/bold yellow] to switch mode")
         self.console.print(f"{CMD_CLEAR:<19}: Clear chat history")
         self.console.print(f"{CMD_HISTORY:<19}: Show chat history")
+        self.console.print(f"{CMD_LIST_CHATS:<19}: List saved chats")
+        save_cmd = f"{CMD_SAVE_CHAT} <title>"
+        self.console.print(f"{save_cmd:<19}: Save current chat")
+        load_cmd = f"{CMD_LOAD_CHAT} <index>"
+        self.console.print(f"{load_cmd:<19}: Load a saved chat")
+        delete_cmd = f"{CMD_DELETE_CHAT} <index>"
+        self.console.print(f"{delete_cmd:<19}: Delete a saved chat")
         cmd_exit = f"{CMD_EXIT}|Ctrl+D|Ctrl+C"
         self.console.print(f"{cmd_exit:<19}: Exit")
         cmd_mode = f"{CMD_MODE} {CHAT_MODE}|{EXEC_MODE}"
@@ -264,7 +452,7 @@ class CLI:
         self.prepare_chat_loop()
         self._print_welcome_message()
         while True:
-            self.console.print(Markdown("---", code_theme=self.config.get("CODE_THEME", "monokai")))
+            self.console.print(Markdown("---", code_theme=self.config["CODE_THEME"]))
             try:
                 user_input = self.session.prompt(self.get_prompt_tokens)
                 user_input = user_input.strip()
@@ -279,22 +467,12 @@ class CLI:
                     break
             except (KeyboardInterrupt, EOFError):
                 break
-        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)
+        # Auto-save chat history when exiting if there are messages and not a temporary session
+        if not self.is_temp_session:
+            self._save_chat(self.chat_title)
 
-        if is_shell_mode:
-            self._confirm_and_execute(content)
+        self.console.print("\nExiting YAICLI... Goodbye!", style="bold green")
 
     def prepare_chat_loop(self) -> None:
         """Setup key bindings and history for interactive modes."""
@@ -310,6 +488,10 @@ class CLI:
         except Exception as e:
             self.console.print(f"[red]Error initializing prompt session history: {e}[/red]")
             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:
         """Setup keyboard shortcuts (e.g., TAB for mode switching)."""
@@ -318,15 +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
+    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)
+
+        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,65 +1,21 @@
 import configparser
+from functools import lru_cache
 from os import getenv
-from pathlib import Path
 from typing import Optional
 
 from rich import get_console
 from rich.console import Console
 
+from yaicli.const import (
+    CONFIG_PATH,
+    DEFAULT_CHAT_HISTORY_DIR,
+    DEFAULT_CONFIG_INI,
+    DEFAULT_CONFIG_MAP,
+    DEFAULT_JUSTIFY,
+    DEFAULT_MAX_SAVED_CHATS,
+)
 from yaicli.utils import str2bool
 
-DEFAULT_CONFIG_MAP = {
-    # Core API settings
-    "BASE_URL": {"value": "https://api.openai.com/v1", "env_key": "YAI_BASE_URL", "type": str},
-    "API_KEY": {"value": "", "env_key": "YAI_API_KEY", "type": str},
-    "MODEL": {"value": "gpt-4o", "env_key": "YAI_MODEL", "type": str},
-    # System detection hints
-    "SHELL_NAME": {"value": "auto", "env_key": "YAI_SHELL_NAME", "type": str},
-    "OS_NAME": {"value": "auto", "env_key": "YAI_OS_NAME", "type": str},
-    # API response parsing
-    "COMPLETION_PATH": {"value": "chat/completions", "env_key": "YAI_COMPLETION_PATH", "type": str},
-    "ANSWER_PATH": {"value": "choices[0].message.content", "env_key": "YAI_ANSWER_PATH", "type": str},
-    # API call parameters
-    "STREAM": {"value": "true", "env_key": "YAI_STREAM", "type": bool},
-    "TEMPERATURE": {"value": "0.7", "env_key": "YAI_TEMPERATURE", "type": float},
-    "TOP_P": {"value": "1.0", "env_key": "YAI_TOP_P", "type": float},
-    "MAX_TOKENS": {"value": "1024", "env_key": "YAI_MAX_TOKENS", "type": int},
-    # UI/UX settings
-    "CODE_THEME": {"value": "monokai", "env_key": "YAI_CODE_THEME", "type": str},
-    "MAX_HISTORY": {"value": "500", "env_key": "YAI_MAX_HISTORY", "type": int},
-    "AUTO_SUGGEST": {"value": "true", "env_key": "YAI_AUTO_SUGGEST", "type": bool},
-}
-
-DEFAULT_CONFIG_INI = f"""[core]
-PROVIDER=openai
-BASE_URL={DEFAULT_CONFIG_MAP["BASE_URL"]["value"]}
-API_KEY={DEFAULT_CONFIG_MAP["API_KEY"]["value"]}
-MODEL={DEFAULT_CONFIG_MAP["MODEL"]["value"]}
-
-# auto detect shell and os (or specify manually, e.g., bash, zsh, powershell.exe)
-SHELL_NAME={DEFAULT_CONFIG_MAP["SHELL_NAME"]["value"]}
-OS_NAME={DEFAULT_CONFIG_MAP["OS_NAME"]["value"]}
-
-# API paths (usually no need to change for OpenAI compatible APIs)
-COMPLETION_PATH={DEFAULT_CONFIG_MAP["COMPLETION_PATH"]["value"]}
-ANSWER_PATH={DEFAULT_CONFIG_MAP["ANSWER_PATH"]["value"]}
-
-# true: streaming response, false: non-streaming
-STREAM={DEFAULT_CONFIG_MAP["STREAM"]["value"]}
-
-# LLM parameters
-TEMPERATURE={DEFAULT_CONFIG_MAP["TEMPERATURE"]["value"]}
-TOP_P={DEFAULT_CONFIG_MAP["TOP_P"]["value"]}
-MAX_TOKENS={DEFAULT_CONFIG_MAP["MAX_TOKENS"]["value"]}
-
-# UI/UX
-CODE_THEME={DEFAULT_CONFIG_MAP["CODE_THEME"]["value"]}
-MAX_HISTORY={DEFAULT_CONFIG_MAP["MAX_HISTORY"]["value"]}
-AUTO_SUGGEST={DEFAULT_CONFIG_MAP["AUTO_SUGGEST"]["value"]}
-"""
-
-CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
-
 
 class CasePreservingConfigParser(configparser.RawConfigParser):
     """Case preserving config parser"""
@@ -82,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()
 
@@ -95,9 +52,7 @@ class Config(dict):
         self.update(self._load_defaults())
 
         # Load from config file
-        file_config = self._load_from_file()
-        if file_config:
-            self.update(file_config)
+        self._load_from_file()
 
         # Load from environment variables and apply type conversion
         self._load_from_env()
@@ -111,26 +66,46 @@ class Config(dict):
         """
         return {k: v["value"] for k, v in DEFAULT_CONFIG_MAP.items()}
 
-    def _load_from_file(self) -> dict[str, str]:
+    def _ensure_version_updated_config_keys(self):
+        """Ensure configuration keys added in version updates exist in the config file.
+        Appends missing keys to the config file if they don't exist.
+        """
+        with open(CONFIG_PATH, "r+", encoding="utf-8") as f:
+            config_content = f.read()
+            if "CHAT_HISTORY_DIR" not in config_content.strip():  # Check for empty lines
+                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.
 
         Creates default config file if it doesn't exist.
-
-        Returns:
-            Dictionary with configuration values from file, or empty dict if no valid values
         """
         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)
-            return {}
+            return
 
         config_parser = CasePreservingConfigParser()
         config_parser.read(CONFIG_PATH, encoding="utf-8")
-        if "core" in config_parser:
-            return {k: v for k, v in config_parser["core"].items() if k in DEFAULT_CONFIG_MAP and v.strip()}
-        return {}
+
+        # Check if "core" section exists in the config file
+        if "core" not in config_parser or not config_parser["core"]:
+            return
+
+        for k, v in {"SHELL_NAME": "Unknown Shell", "OS_NAME": "Unknown OS"}.items():
+            if not config_parser["core"].get(k, "").strip():
+                config_parser["core"][k] = v
+
+        self.update(config_parser["core"])
+
+        # Check if keys added in version updates are missing and add them
+        self._ensure_version_updated_config_keys()
 
     def _load_from_env(self) -> None:
         """Load configuration from environment variables.
@@ -165,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:
@@ -177,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()