ara-cli 0.1.9.86__tar.gz → 0.1.9.87__tar.gz

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.86
+Version: 0.1.9.87
 Summary: Powerful, open source command-line tool for managing, structuring and automating software development artifacts in line with Business-Driven Development (BDD) and AI-assisted processes
 Description-Content-Type: text/markdown
 Requires-Dist: litellm

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/ara_cli/ara_config.py

@@ -1,5 +1,5 @@
 from typing import List, Dict, Optional, Any
-from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
+from pydantic import BaseModel, ValidationError, Field, model_validator
 import json
 import os
 from os.path import exists, dirname
@@ -14,23 +14,11 @@ class LLMConfigItem(BaseModel):
     model: str
     temperature: float = Field(ge=0.0, le=1.0)
     max_tokens: Optional[int] = None
-    
-    @field_validator('temperature')
-    @classmethod
-    def validate_temperature(cls, v: float, info) -> float:
-        if not 0.0 <= v <= 1.0:
-            print(f"Warning: Temperature is outside the 0.0 to 1.0 range")
-            # Return a valid default
-            return 0.8
-        return v
-
-class ExtCodeDirItem(BaseModel):
-    source_dir: str
 
 class ARAconfig(BaseModel):
-    ext_code_dirs: List[ExtCodeDirItem] = Field(default_factory=lambda: [
-        ExtCodeDirItem(source_dir="./src"),
-        ExtCodeDirItem(source_dir="./tests")
+    ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
+        {"source_dir": "./src"},
+        {"source_dir": "./tests"}
     ])
     glossary_dir: str = "./glossary"
     doc_dir: str = "./docs"
@@ -98,27 +86,21 @@ class ARAconfig(BaseModel):
         )
     })
     default_llm: Optional[str] = "gpt-4o"
-    
-    model_config = {
-        "extra": "forbid"  # This will help identify unrecognized keys
-    }
 
     @model_validator(mode='after')
     def check_critical_fields(self) -> 'ARAconfig':
-        """Check for empty critical fields and use defaults if needed"""
+        """Check for empty critical fields and use defaults if needed."""
         critical_fields = {
-            'ext_code_dirs': [ExtCodeDirItem(source_dir="./src"), ExtCodeDirItem(source_dir="./tests")],
+            'ext_code_dirs': [{"source_dir": "./src"}, {"source_dir": "./tests"}],
             'local_ara_templates_dir': "./ara/.araconfig/templates/",
             'local_prompt_templates_dir': "./ara/.araconfig",
             'glossary_dir': "./glossary"
         }
-        
+
         for field, default_value in critical_fields.items():
             current_value = getattr(self, field)
-            if (not current_value or 
-                (isinstance(current_value, list) and len(current_value) == 0) or
-                (isinstance(current_value, str) and current_value.strip() == "")):
-                print(f"Warning: Value for '{field}' is missing or empty.")
+            if not current_value:
+                print(f"Warning: Value for '{field}' is missing or empty. Using default.")
                 setattr(self, field, default_value)
         
         return self
@@ -126,109 +108,80 @@ class ARAconfig(BaseModel):
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
 def ensure_directory_exists(directory: str):
+    """Creates a directory if it doesn't exist."""
     if not exists(directory):
         os.makedirs(directory)
         print(f"New directory created at {directory}")
     return directory
 
-def handle_unrecognized_keys(data: dict, known_fields: set) -> dict:
-    """Remove unrecognized keys and warn the user"""
+def handle_unrecognized_keys(data: dict) -> dict:
+    """Removes unrecognized keys from the data and warns the user."""
+    known_fields = set(ARAconfig.model_fields.keys())
     cleaned_data = {}
     for key, value in data.items():
         if key not in known_fields:
-            print(f"Warning: {key} is not recognized as a valid configuration option.")
+            print(f"Warning: Unrecognized configuration key '{key}' will be ignored.")
         else:
             cleaned_data[key] = value
     return cleaned_data
 
-def fix_llm_temperatures(data: dict) -> dict:
-    """Fix invalid temperatures in LLM configurations"""
-    if 'llm_config' in data:
-        for model_key, model_config in data['llm_config'].items():
-            if isinstance(model_config, dict) and 'temperature' in model_config:
-                temp = model_config['temperature']
-                if not 0.0 <= temp <= 1.0:
-                    print(f"Warning: Temperature for model '{model_key}' is outside the 0.0 to 1.0 range")
-                    model_config['temperature'] = 0.8
-    return data
-
-def validate_and_fix_config_data(filepath: str) -> dict:
-    """Load, validate, and fix configuration data"""
-    try:
-        with open(filepath, "r", encoding="utf-8") as file:
-            data = json.load(file)
-        
-        # Get known fields from the ARAconfig model
-        known_fields = set(ARAconfig.model_fields.keys())
-        
-        # Handle unrecognized keys
-        data = handle_unrecognized_keys(data, known_fields)
-        
-        # Fix LLM temperatures before validation
-        data = fix_llm_temperatures(data)
-        
-        return data
-    except json.JSONDecodeError as e:
-        print(f"Error: Invalid JSON in configuration file: {e}")
-        print("Creating new configuration with defaults...")
-        return {}
-    except Exception as e:
-        print(f"Error reading configuration file: {e}")
-        return {}
-
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
-    # Ensure the directory for the config file exists
-    config_dir = dirname(filepath)
-    ensure_directory_exists(config_dir)
+    """
+    Reads, validates, and repairs the configuration file.
+    If the file doesn't exist, it creates a default one.
+    If the file is invalid, it corrects only the broken parts.
+    """
+    ensure_directory_exists(dirname(filepath))
 
     if not exists(filepath):
-        # If the file does not exist, create it with default values
+        print(f"Configuration file not found. Creating a default one at '{filepath}'.")
         default_config = ARAconfig()
         save_data(filepath, default_config)
-        print(
-            f"ara-cli configuration file '{filepath}' created with default configuration."
-            f" Please modify it as needed and re-run your command"
-        )
-        sys.exit(0)  # Exit the application
+        print("Please review the default configuration and re-run your command.")
+        sys.exit(0)
+
+    try:
+        with open(filepath, "r", encoding="utf-8") as file:
+            data = json.load(file)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        print("Creating a new configuration with defaults...")
+        default_config = ARAconfig()
+        save_data(filepath, default_config)
+        return default_config
+
+    data = handle_unrecognized_keys(data)
 
-    # Validate and load the existing configuration
-    data = validate_and_fix_config_data(filepath)
-    
     try:
-        # Try to create the config with the loaded data
         config = ARAconfig(**data)
-        
-        # Save the potentially fixed configuration back
         save_data(filepath, config)
-        
         return config
     except ValidationError as e:
-        print(f"ValidationError: {e}")
-        print("Correcting configuration with default values...")
+        print("--- Configuration Error Detected ---")
+        print("Some settings in your configuration file are invalid. Attempting to fix them.")
         
-        # Create a default config
-        default_config = ARAconfig()
+        corrected_data = data.copy()
+        defaults = ARAconfig().model_dump()
         
-        # Try to preserve valid fields from the original data
-        for field_name, field_value in data.items():
-            if field_name in ARAconfig.model_fields:
-                try:
-                    # Attempt to set the field value
-                    setattr(default_config, field_name, field_value)
-                except:
-                    # If it fails, keep the default
-                    pass
+        error_fields = {err['loc'][0] for err in e.errors() if err['loc']}
         
-        # Save the corrected configuration
-        save_data(filepath, default_config)
-        print("Fixed configuration saved to file.")
+        for field_name in error_fields:
+            print(f"-> Field '{field_name}' is invalid and will be reverted to its default value.")
+            corrected_data[field_name] = defaults.get(field_name)
+
+        print("--- End of Error Report ---")
+
+        final_config = ARAconfig(**corrected_data)
+        save_data(filepath, final_config)
+        print(f"Configuration has been corrected and saved to '{filepath}'.")
         
-        return default_config
+        return final_config
 
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
+    """Saves the Pydantic config model to a JSON file."""
     with open(filepath, "w", encoding="utf-8") as file:
         json.dump(config.model_dump(), file, indent=4)
 
@@ -237,18 +190,13 @@ class ConfigManager:
     _config_instance = None
 
     @classmethod
-    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION):
+    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION) -> ARAconfig:
         if cls._config_instance is None:
-            config_dir = dirname(filepath)
-
-            if not exists(config_dir):
-                makedirs(config_dir)
-
             cls._config_instance = read_data(filepath)
         return cls._config_instance
     
     @classmethod
     def reset(cls):
-        """Reset the configuration instance (useful for testing)"""
+        """Reset the configuration instance (useful for testing)."""
         cls._config_instance = None
         read_data.cache_clear()

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/ara_cli/prompt_handler.py

@@ -15,8 +15,6 @@ import glob
 import logging
 
 
-
-
 class LLMSingleton:
     _instance = None
     _model = None
@@ -27,8 +25,7 @@ class LLMSingleton:
 
         if not selected_config:
             raise ValueError(f"No configuration found for the model: {model_id}")
-        if not isinstance(selected_config, LLMConfigItem):
-            selected_config = LLMConfigItem(**selected_config)
+        
         LLMSingleton._model = model_id
 
         # Typesafe for None values inside the config.
@@ -495,7 +492,7 @@ def generate_config_prompt_template_file(prompt_data_path, config_prompt_templat
 def generate_config_prompt_givens_file(prompt_data_path, config_prompt_givens_name, artefact_to_mark=None):
     config_prompt_givens_path = os.path.join(prompt_data_path, config_prompt_givens_name)
     config = ConfigManager.get_config()
-    dir_list = ["ara"] + [ext.source_dir for ext in config.ext_code_dirs] + [config.doc_dir] + [config.glossary_dir]
+    dir_list = ["ara"] + [ext['source_dir'] for ext in config.ext_code_dirs] + [config.doc_dir] + [config.glossary_dir]
 
     print(f"used {dir_list} for prompt givens file listing")
     generate_markdown_listing(dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path)

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/ara_cli/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.9.86"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers
+__version__ = "0.1.9.87"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/ara_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.86
+Version: 0.1.9.87
 Summary: Powerful, open source command-line tool for managing, structuring and automating software development artifacts in line with Business-Driven Development (BDD) and AI-assisted processes
 Description-Content-Type: text/markdown
 Requires-Dist: litellm

{ara_cli-0.1.9.86 → ara_cli-0.1.9.87}/ara_cli.egg-info/SOURCES.txt

@@ -159,6 +159,7 @@ tests/test_file_classifier.py
 tests/test_file_creator.py
 tests/test_file_lister.py
 tests/test_list_filter.py
+tests/test_prompt_handler.py
 tests/test_tag_extractor.py
 tests/test_template_manager.py
 tests/test_update_config_prompt.py

ara_cli-0.1.9.87/tests/test_ara_config.py

@@ -0,0 +1,336 @@
+import os
+import json
+import pytest
+from unittest.mock import patch, mock_open, MagicMock
+import sys
+from io import StringIO
+from pydantic import ValidationError
+
+# Assuming the test file is structured to import from the production code module
+from ara_cli.ara_config import (
+    ensure_directory_exists,
+    read_data,
+    save_data,
+    ARAconfig,
+    ConfigManager,
+    DEFAULT_CONFIG_LOCATION,
+    LLMConfigItem,
+    handle_unrecognized_keys,
+)
+
+
+@pytest.fixture
+def default_config_data():
+    """Provides the default configuration as a dictionary."""
+    return ARAconfig().model_dump()
+
+
+@pytest.fixture
+def valid_config_dict():
+    """A valid, non-default configuration dictionary for testing."""
+    return {
+        "ext_code_dirs": [{"source_dir": "./app"}],
+        "glossary_dir": "./custom_glossary",
+        "doc_dir": "./custom_docs",
+        "local_prompt_templates_dir": "./custom_prompts",
+        "custom_prompt_templates_subdir": "custom_subdir",
+        "local_ara_templates_dir": "./custom_templates/",
+        "ara_prompt_given_list_includes": ["*.py", "*.md", "*.json"],
+        "llm_config": {
+            "gpt-4o-custom": {
+                "provider": "openai",
+                "model": "openai/gpt-4o",
+                "temperature": 0.5,
+                "max_tokens": 4096
+            }
+        },
+        "default_llm": "gpt-4o-custom"
+    }
+
+
+@pytest.fixture
+def corrupted_config_dict():
+    """A config dictionary with various type errors to test validation and fixing."""
+    return {
+        "ext_code_dirs": "should_be_a_list",
+        "glossary_dir": 123,
+        "llm_config": {
+            "bad-model": {
+                "provider": "test",
+                "model": "test/model",
+                "temperature": "not_a_float"
+            }
+        },
+        "default_llm": 999
+    }
+
+
+@pytest.fixture(autouse=True)
+def reset_config_manager():
+    """Ensures a clean state for each test by resetting the singleton and caches."""
+    ConfigManager.reset()
+    yield
+    ConfigManager.reset()
+
+# --- Test Pydantic Models ---
+
+class TestLLMConfigItem:
+    def test_valid_temperature(self):
+        """Tests that a valid temperature is accepted."""
+        config = LLMConfigItem(provider="test", model="test/model", temperature=0.7)
+        assert config.temperature == 0.7
+
+    def test_invalid_temperature_too_high_raises_error(self):
+        """Tests that temperature > 1.0 raises a ValidationError."""
+        with pytest.raises(ValidationError, match="Input should be less than or equal to 1"):
+            LLMConfigItem(provider="test", model="test/model", temperature=1.5)
+
+    def test_invalid_temperature_too_low_raises_error(self):
+        """Tests that temperature < 0.0 raises a ValidationError."""
+        with pytest.raises(ValidationError, match="Input should be greater than or equal to 0"):
+            LLMConfigItem(provider="test", model="test/model", temperature=-0.5)
+
+
+class TestARAconfig:
+    def test_default_values_are_correct(self):
+        """Tests that the model initializes with correct default values."""
+        config = ARAconfig()
+        assert config.ext_code_dirs == [{"source_dir": "./src"}, {"source_dir": "./tests"}]
+        assert config.glossary_dir == "./glossary"
+        assert config.default_llm == "gpt-4o"
+        assert "gpt-4o" in config.llm_config
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_check_critical_fields_with_empty_list_reverts_to_default(self, mock_stdout):
+        """Tests that an empty list for a critical field is reverted to its default."""
+        config = ARAconfig(ext_code_dirs=[])
+        assert len(config.ext_code_dirs) == 2
+        assert config.ext_code_dirs[0] == {"source_dir": "./src"}
+        assert "Warning: Value for 'ext_code_dirs' is missing or empty. Using default." in mock_stdout.getvalue()
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_check_critical_fields_with_empty_string_reverts_to_default(self, mock_stdout):
+        """Tests that an empty string for a critical field is reverted to its default."""
+        config = ARAconfig(glossary_dir="")
+        assert config.glossary_dir == "./glossary"
+        assert "Warning: Value for 'glossary_dir' is missing or empty. Using default." in mock_stdout.getvalue()
+
+# --- Test Helper Functions ---
+
+class TestEnsureDirectoryExists:
+    @patch('sys.stdout', new_callable=StringIO)
+    @patch("os.makedirs")
+    @patch("ara_cli.ara_config.exists", return_value=False)
+    def test_directory_creation_when_not_exists(self, mock_exists, mock_makedirs, mock_stdout):
+        """Tests that a directory is created if it doesn't exist."""
+        ensure_directory_exists.cache_clear()
+        directory = "/tmp/new/dir"
+        result = ensure_directory_exists(directory)
+        
+        mock_exists.assert_called_once_with(directory)
+        mock_makedirs.assert_called_once_with(directory)
+        assert result == directory
+        assert f"New directory created at {directory}" in mock_stdout.getvalue()
+
+    @patch("os.makedirs")
+    @patch("ara_cli.ara_config.exists", return_value=True)
+    def test_directory_no_creation_when_exists(self, mock_exists, mock_makedirs):
+        """Tests that a directory is not created if it already exists."""
+        ensure_directory_exists.cache_clear()
+        directory = "/tmp/existing/dir"
+        result = ensure_directory_exists(directory)
+        
+        mock_exists.assert_called_once_with(directory)
+        mock_makedirs.assert_not_called()
+        assert result == directory
+
+
+class TestHandleUnrecognizedKeys:
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_removes_unrecognized_keys_and_warns(self, mock_stdout):
+        """Tests that unknown keys are removed and a warning is printed."""
+        data = {"glossary_dir": "./glossary", "unknown_key": "some_value"}
+        cleaned_data = handle_unrecognized_keys(data)
+        
+        assert "unknown_key" not in cleaned_data
+        assert "glossary_dir" in cleaned_data
+        assert "Warning: Unrecognized configuration key 'unknown_key' will be ignored." in mock_stdout.getvalue()
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_no_action_for_valid_data(self, mock_stdout):
+        """Tests that no changes are made when there are no unrecognized keys."""
+        data = {"glossary_dir": "./glossary", "doc_dir": "./docs"}
+        cleaned_data = handle_unrecognized_keys(data)
+        
+        assert cleaned_data == data
+        assert mock_stdout.getvalue() == ""
+
+# --- Test Core I/O and Logic ---
+
+class TestSaveData:
+    @patch("builtins.open", new_callable=mock_open)
+    def test_save_data_writes_correct_json(self, mock_file, default_config_data):
+        """Tests that the config is correctly serialized to a JSON file."""
+        config = ARAconfig()
+        save_data("config.json", config)
+
+        mock_file.assert_called_once_with("config.json", "w", encoding="utf-8")
+        handle = mock_file()
+        written_data = ''.join(call.args[0] for call in handle.write.call_args_list)
+        
+        assert json.loads(written_data) == default_config_data
+
+
+class TestReadData:
+    @patch('sys.stdout', new_callable=StringIO)
+    @patch('ara_cli.ara_config.save_data')
+    @patch('ara_cli.ara_config.ensure_directory_exists')
+    @patch('ara_cli.ara_config.exists', return_value=False)
+    def test_file_not_found_creates_default_and_exits(self, mock_exists, mock_ensure_dir, mock_save, mock_stdout):
+        """Tests that a default config is created and the program exits if no config file is found."""
+        with pytest.raises(SystemExit) as exc_info:
+            read_data.cache_clear()
+            read_data("config.json")
+
+        assert exc_info.value.code == 0
+        mock_ensure_dir.assert_called_once_with(os.path.dirname("config.json"))
+        mock_save.assert_called_once()
+        
+        output = mock_stdout.getvalue()
+        assert "Configuration file not found. Creating a default one at 'config.json'." in output
+        assert "Please review the default configuration and re-run your command." in output
+
+    @patch('ara_cli.ara_config.save_data')
+    @patch('builtins.open')
+    @patch('ara_cli.ara_config.ensure_directory_exists')
+    @patch('ara_cli.ara_config.exists', return_value=True)
+    def test_valid_config_is_loaded_and_resaved(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, valid_config_dict):
+        """Tests that a valid config is loaded correctly and re-saved (to clean it)."""
+        m = mock_open(read_data=json.dumps(valid_config_dict))
+        mock_open_func.return_value = m()
+        read_data.cache_clear()
+
+        result = read_data("config.json")
+
+        assert isinstance(result, ARAconfig)
+        assert result.default_llm == "gpt-4o-custom"
+        mock_save.assert_called_once()
+
+    @patch('sys.stdout', new_callable=StringIO)
+    @patch('ara_cli.ara_config.save_data')
+    @patch('builtins.open', new_callable=mock_open, read_data="this is not json")
+    @patch('ara_cli.ara_config.ensure_directory_exists')
+    @patch('ara_cli.ara_config.exists', return_value=True)
+    def test_invalid_json_creates_default_config(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout):
+        """Tests that a JSON decoding error results in a new default configuration."""
+        read_data.cache_clear()
+        
+        result = read_data("config.json")
+        
+        assert isinstance(result, ARAconfig)
+        assert result.default_llm == "gpt-4o"  # Should be the default config
+        
+        output = mock_stdout.getvalue()
+        assert "Error: Invalid JSON in configuration file" in output
+        assert "Creating a new configuration with defaults..." in output
+        mock_save.assert_called_once()
+
+    @patch('sys.stdout', new_callable=StringIO)
+    @patch('ara_cli.ara_config.save_data')
+    @patch('builtins.open')
+    @patch('ara_cli.ara_config.ensure_directory_exists')
+    @patch('ara_cli.ara_config.exists', return_value=True)
+    def test_config_with_validation_errors_is_fixed(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout, corrupted_config_dict):
+        """Tests that a config with invalid fields is automatically corrected to defaults."""
+        m = mock_open(read_data=json.dumps(corrupted_config_dict))
+        mock_open_func.return_value = m()
+        read_data.cache_clear()
+        
+        defaults = ARAconfig()
+        result = read_data("config.json")
+
+        assert isinstance(result, ARAconfig)
+        assert result.ext_code_dirs == defaults.ext_code_dirs
+        assert result.glossary_dir == defaults.glossary_dir
+        assert result.llm_config == defaults.llm_config
+        assert result.default_llm == defaults.default_llm
+
+        output = mock_stdout.getvalue()
+        assert "--- Configuration Error Detected ---" in output
+        assert "-> Field 'ext_code_dirs' is invalid and will be reverted to its default value." in output
+        assert "-> Field 'glossary_dir' is invalid and will be reverted to its default value." in output
+        assert "-> Field 'llm_config' is invalid and will be reverted to its default value." in output
+        assert "Configuration has been corrected and saved" in output
+        
+        mock_save.assert_called_once_with("config.json", result)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    @patch('ara_cli.ara_config.save_data')
+    @patch('builtins.open')
+    @patch('ara_cli.ara_config.ensure_directory_exists')
+    @patch('ara_cli.ara_config.exists', return_value=True)
+    def test_preserves_valid_fields_when_fixing_errors(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout):
+        """Tests that valid, non-default values are preserved during a fix."""
+        mixed_config = {
+            "glossary_dir": "./my-custom-glossary",  # Valid, non-default
+            "default_llm": 12345,                    # Invalid type
+            "unrecognized_key": "will_be_ignored"    # Unrecognized
+        }
+        m = mock_open(read_data=json.dumps(mixed_config))
+        mock_open_func.return_value = m()
+        read_data.cache_clear()
+        
+        defaults = ARAconfig()
+        result = read_data("config.json")
+
+        assert result.glossary_dir == "./my-custom-glossary"
+        assert result.default_llm == defaults.default_llm
+
+        output = mock_stdout.getvalue()
+        assert "Warning: Unrecognized configuration key 'unrecognized_key' will be ignored." in output
+        assert "-> Field 'default_llm' is invalid" in output
+        assert "-> Field 'glossary_dir' is invalid" not in output
+
+        mock_save.assert_called_once()
+        saved_config = mock_save.call_args[0][1]
+        assert saved_config.glossary_dir == "./my-custom-glossary"
+        assert saved_config.default_llm == defaults.default_llm
+
+# --- Test Singleton Manager ---
+
+class TestConfigManager:
+    @patch('ara_cli.ara_config.read_data')
+    def test_get_config_is_singleton(self, mock_read):
+        """Tests that get_config returns the same instance on subsequent calls."""
+        mock_read.return_value = MagicMock(spec=ARAconfig)
+        
+        config1 = ConfigManager.get_config()
+        config2 = ConfigManager.get_config()
+        
+        assert config1 is config2
+        mock_read.assert_called_once()
+
+    @patch('ara_cli.ara_config.read_data')
+    def test_reset_clears_instance_and_caches(self, mock_read):
+        """Tests that the reset method clears the instance and underlying caches."""
+        mock_read.return_value = MagicMock(spec=ARAconfig)
+
+        ConfigManager.get_config()
+        mock_read.assert_called_once()
+        
+        ConfigManager.reset()
+        assert ConfigManager._config_instance is None
+        mock_read.cache_clear.assert_called_once()
+
+        ConfigManager.get_config()
+        assert mock_read.call_count == 2 # Called again after reset
+
+    @patch('ara_cli.ara_config.read_data')
+    def test_get_config_with_custom_filepath(self, mock_read):
+        """Tests that get_config can be called with a custom file path."""
+        mock_read.return_value = MagicMock(spec=ARAconfig)
+        custom_path = "/custom/path/config.json"
+        
+        ConfigManager.get_config(custom_path)
+        
+        mock_read.assert_called_once_with(custom_path)