ara-cli 0.1.9.86__py3-none-any.whl → 0.1.9.87__py3-none-any.whl

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/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/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.dist-info → ara_cli-0.1.9.87.dist-info}/METADATA

@@ -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.dist-info → ara_cli-0.1.9.87.dist-info}/RECORD

@@ -2,7 +2,7 @@ ara_cli/__init__.py,sha256=0zl7IegxTid26EBGLav_fXZ4CCIV3H5TfAoFQiOHjvg,148
 ara_cli/__main__.py,sha256=J5DCDLRZ6UcpYwM1-NkjaLo4PTetcSj2dB4HrrftkUw,2064
 ara_cli/ara_command_action.py,sha256=_LHE2V5hbJxN7ccYiptuPktRfbTnXmQEt_D_FxDBlBY,22456
 ara_cli/ara_command_parser.py,sha256=I-e9W-QwTIMKMzlHycSlCWCyBFQfiFYvGre1XsDbrFI,20573
-ara_cli/ara_config.py,sha256=SgZfQVpqj5JJN4SB0n2IvAH0sKIdS3k1K1Zht2wDywA,8814
+ara_cli/ara_config.py,sha256=KVITofnYlIVyhf50qwUO5fu8vlxjDwRjPyKzqEhEC_M,6982
 ara_cli/artefact_autofix.py,sha256=WVTiIR-jo4YKmmz4eS3qTFvl45W1YKwAk1XSuz9QX10,20015
 ara_cli/artefact_creator.py,sha256=0Ory6cB-Ahkw-BDNb8QHnTbp_OHGABdkb9bhwcEdcIc,6063
 ara_cli/artefact_deleter.py,sha256=Co4wwCH3yW8H9NrOq7_2p5571EeHr0TsfE-H8KqoOfY,1900
@@ -25,13 +25,13 @@ ara_cli/list_filter.py,sha256=qKGwwQsrWe7L5FbdxEbBYD1bbbi8c-RMypjXqXvLbgs,5291
 ara_cli/output_suppressor.py,sha256=nwiHaQLwabOjMoJOeUESBnZszGMxrQZfJ3N2OvahX7Y,389
 ara_cli/prompt_chat.py,sha256=kd_OINDQFit6jN04bb7mzgY259JBbRaTaNp9F-webkc,1346
 ara_cli/prompt_extractor.py,sha256=6xLGd4ZJHDKkamEUQcdRbKM3ilBtxBjp0X2o8wrvHb0,7732
-ara_cli/prompt_handler.py,sha256=iulI3A4lHXvVITX7hiVN-pR61bzJmIfoYMGK_aO2Pfs,20248
+ara_cli/prompt_handler.py,sha256=5FoVCNmmzrS4hjHL4qKteQt2A5MIycoZStkJrVL5l_4,20136
 ara_cli/prompt_rag.py,sha256=ydlhe4CUqz0jdzlY7jBbpKaf_5fjMrAZKnriKea3ZAg,7485
 ara_cli/run_file_lister.py,sha256=XbrrDTJXp1LFGx9Lv91SNsEHZPP-PyEMBF_P4btjbDA,2360
 ara_cli/tag_extractor.py,sha256=TGdaQOVnjy25R0zDsAifB67C5oom0Fwo24s0_fr5A_I,3151
 ara_cli/template_manager.py,sha256=YwrN6AYPpl6ZrW8BVQpVXx8yTRf-oNpJUIKeg4NAggs,6606
 ara_cli/update_config_prompt.py,sha256=Oy9vNTw6UhDohyTEfSKkqE5ifEMPlmWNYkKHgUrK_pY,4607
-ara_cli/version.py,sha256=3fpgzO-uIT17SkvY-eWOWvuwKw3R0Pg3_9_JwMnXP8Q,146
+ara_cli/version.py,sha256=27waJFP_fluwJJNMwbe3_NlHJaeI6oPvAK2CQIhI63w,146
 ara_cli/artefact_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ara_cli/artefact_models/artefact_load.py,sha256=IXzWxP-Q_j_oDGMno0m-OuXCQ7Vd5c_NctshGr4ROBw,621
 ara_cli/artefact_models/artefact_mapping.py,sha256=8aD0spBjkJ8toMAmFawc6UTUxB6-tEEViZXv2I-r88Q,1874
@@ -134,7 +134,7 @@ ara_cli/templates/specification_breakdown_files/template.technology.exploration.
 ara_cli/templates/specification_breakdown_files/template.technology.md,sha256=bySiksz-8xtq0Nnj4svqe2MgUftWrVkbK9AcrDUE3KY,952
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_ara_command_action.py,sha256=JTLqXM9BSMlU33OQgrk_sZnoowFJZKZAx8q-st-wa34,25821
-tests/test_ara_config.py,sha256=pvkdPLTzgLkOijil0HaN0mhLC2Rdu4Fu5RfXEyOlRfs,16672
+tests/test_ara_config.py,sha256=gYqBB4Z7lB0PTSZrJRL7ekC0t9HZ_Rq3JF9EnOFmN5U,14280
 tests/test_artefact_autofix.py,sha256=pApZ-N0dW8Ujt-cNLbgvd4bhiIIK8oXb-saLf6QlA-8,25022
 tests/test_artefact_fuzzy_search.py,sha256=5Sh3_l9QK8-WHn6JpGPU1b6h4QEnl2JoMq1Tdp2cj1U,1261
 tests/test_artefact_link_updater.py,sha256=biqbEp2jCOz8giv72hu2P2hDfeJfJ9OrVGdAv5d9cK4,2191
@@ -149,11 +149,12 @@ tests/test_file_classifier.py,sha256=kLWPiePu3F5mkVuI_lK_2QlLh2kXD_Mt2K8KZZ1fAnA
 tests/test_file_creator.py,sha256=D3G7MbgE0m8JmZihxnTryxLco6iZdbV--2CGc0L20FM,2109
 tests/test_file_lister.py,sha256=Q9HwhKKx540EPzTmfzOCnvtAgON0aMmpJE2eOe1J3EA,4324
 tests/test_list_filter.py,sha256=fJA3d_SdaOAUkE7jn68MOVS0THXGghy1fye_64Zvo1U,7964
+tests/test_prompt_handler.py,sha256=7V_AwXd2co1krnx5RKZRK-hqXS50nq77mX-Yx_QO0w0,13084
 tests/test_tag_extractor.py,sha256=nSiAYlTKZ7TLAOtcJpwK5zTWHhFYU0tI5xKnivLc1dU,2712
 tests/test_template_manager.py,sha256=q-LMHRG4rHkD6ON6YW4cpZxUx9hul6Or8wVVRC2kb-8,4099
 tests/test_update_config_prompt.py,sha256=xsqj1WTn4BsG5Q2t-sNPfu7EoMURFcS-hfb5VSXUnJc,6765
-ara_cli-0.1.9.86.dist-info/METADATA,sha256=EN5cqYvzoOF1lBV8pbnV8tGacSKIH1nikcg_ePdbChk,6739
-ara_cli-0.1.9.86.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ara_cli-0.1.9.86.dist-info/entry_points.txt,sha256=v4h7MzysTgSIDYfEo3oj4Kz_8lzsRa3hq-KJHEcLVX8,45
-ara_cli-0.1.9.86.dist-info/top_level.txt,sha256=WM4cLHT5DYUaWzLtRj-gu3yVNFpGQ6lLRI3FMmC-38I,14
-ara_cli-0.1.9.86.dist-info/RECORD,,
+ara_cli-0.1.9.87.dist-info/METADATA,sha256=WKN4uhNXDHMDwwlxkCW5KbBV_2cbeixRkQYsLZNBdLY,6739
+ara_cli-0.1.9.87.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ara_cli-0.1.9.87.dist-info/entry_points.txt,sha256=v4h7MzysTgSIDYfEo3oj4Kz_8lzsRa3hq-KJHEcLVX8,45
+ara_cli-0.1.9.87.dist-info/top_level.txt,sha256=WM4cLHT5DYUaWzLtRj-gu3yVNFpGQ6lLRI3FMmC-38I,14
+ara_cli-0.1.9.87.dist-info/RECORD,,

tests/test_ara_config.py

@@ -1,169 +1,130 @@
 import os
 import json
 import pytest
-from unittest.mock import patch, mock_open, MagicMock, call
-from tempfile import TemporaryDirectory
-from pydantic import ValidationError
+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, 
+    ensure_directory_exists,
+    read_data,
     save_data,
-    ARAconfig, 
-    ConfigManager, 
+    ARAconfig,
+    ConfigManager,
     DEFAULT_CONFIG_LOCATION,
     LLMConfigItem,
-    ExtCodeDirItem,
     handle_unrecognized_keys,
-    fix_llm_temperatures,
-    validate_and_fix_config_data
 )
 
 
 @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": "./src"},
-            {"source_dir": "./tests"}
-        ],
-        "glossary_dir": "./glossary",
-        "doc_dir": "./docs",
-        "local_prompt_templates_dir": "./ara/.araconfig",
-        "custom_prompt_templates_subdir": "custom-prompt-modules",
-        "local_ara_templates_dir": "./ara/.araconfig/templates/",
-        "ara_prompt_given_list_includes": ["*.py", "*.md"],
+        "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": {
+            "gpt-4o-custom": {
                 "provider": "openai",
                 "model": "openai/gpt-4o",
-                "temperature": 0.8,
-                "max_tokens": 16384
+                "temperature": 0.5,
+                "max_tokens": 4096
             }
         },
-        "default_llm": "gpt-4o"
+        "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",  # Wrong type
-        "glossary_dir": 123,  # Should be string
+        "ext_code_dirs": "should_be_a_list",
+        "glossary_dir": 123,
         "llm_config": {
-            "gpt-4o": {
-                "provider": "openai",
-                "model": "openai/gpt-4o",
-                "temperature": "should_be_float",  # Wrong type
-                "max_tokens": "16384"  # Should be int
+            "bad-model": {
+                "provider": "test",
+                "model": "test/model",
+                "temperature": "not_a_float"
             }
-        }
+        },
+        "default_llm": 999
     }
 
 
 @pytest.fixture(autouse=True)
 def reset_config_manager():
-    """Reset ConfigManager before each test"""
+    """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):
-        config = LLMConfigItem(
-            provider="openai",
-            model="gpt-4",
-            temperature=0.7
-        )
+        """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_raises_validation_error(self):
-        # The Field constraint prevents invalid temperatures from being created
-        with pytest.raises(ValidationError) as exc_info:
-            LLMConfigItem(
-                provider="openai",
-                model="gpt-4",
-                temperature=1.5
-            )
-        assert "less than or equal to 1" in str(exc_info.value)
-
-    def test_negative_temperature_raises_validation_error(self):
-        # The Field constraint prevents negative temperatures
-        with pytest.raises(ValidationError) as exc_info:
-            LLMConfigItem(
-                provider="openai",
-                model="gpt-4",
-                temperature=-0.5
-            )
-        assert "greater than or equal to 0" in str(exc_info.value)
-    
-    def test_temperature_validator_with_dict_input(self):
-        # Test the validator through dict input (simulating JSON load)
-        # This tests the fix_llm_temperatures function behavior
-        data = {
-            "provider": "openai",
-            "model": "gpt-4",
-            "temperature": 0.8
-        }
-        config = LLMConfigItem(**data)
-        assert config.temperature == 0.8
-
+    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)
 
-class TestExtCodeDirItem:
-    def test_create_ext_code_dir_item(self):
-        item = ExtCodeDirItem(source_dir="./src")
-        assert item.source_dir == "./src"
+    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(self):
+    def test_default_values_are_correct(self):
+        """Tests that the model initializes with correct default values."""
         config = ARAconfig()
-        assert len(config.ext_code_dirs) == 2
-        assert config.ext_code_dirs[0].source_dir == "./src"
-        assert config.ext_code_dirs[1].source_dir == "./tests"
+        assert config.ext_code_dirs == [{"source_dir": "./src"}, {"source_dir": "./tests"}]
         assert config.glossary_dir == "./glossary"
         assert config.default_llm == "gpt-4o"
-
-    def test_forbid_extra_fields(self):
-        with pytest.raises(ValidationError) as exc_info:
-            ARAconfig(unknown_field="value")
-        assert "Extra inputs are not permitted" in str(exc_info.value)
+        assert "gpt-4o" in config.llm_config
 
     @patch('sys.stdout', new_callable=StringIO)
-    def test_check_critical_fields_empty_list(self, mock_stdout):
+    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 "Warning: Value for 'ext_code_dirs' is missing or empty." in mock_stdout.getvalue()
+        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_empty_string(self, mock_stdout):
+    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." in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_check_critical_fields_whitespace_string(self, mock_stdout):
-        config = ARAconfig(local_prompt_templates_dir="   ")
-        assert config.local_prompt_templates_dir == "./ara/.araconfig"
-        assert "Warning: Value for 'local_prompt_templates_dir' is missing or empty." in mock_stdout.getvalue()
+        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_does_not_exist(self, mock_exists, mock_makedirs, mock_stdout):
-        directory = "/some/non/existent/directory"
-        # Clear the cache before test
+    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)
@@ -173,10 +134,10 @@ class TestEnsureDirectoryExists:
 
     @patch("os.makedirs")
     @patch("ara_cli.ara_config.exists", return_value=True)
-    def test_directory_exists(self, mock_exists, mock_makedirs):
-        directory = "/some/existent/directory"
-        # Clear the cache before test
+    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)
@@ -186,134 +147,37 @@ class TestEnsureDirectoryExists:
 
 class TestHandleUnrecognizedKeys:
     @patch('sys.stdout', new_callable=StringIO)
-    def test_handle_unrecognized_keys(self, mock_stdout):
-        data = {
-            "ext_code_dirs": [],
-            "glossary_dir": "./glossary",
-            "unknown_key": "value"
-        }
-        known_fields = {"ext_code_dirs", "glossary_dir"}
-        
-        result = handle_unrecognized_keys(data, known_fields)
-        
-        assert "unknown_key" not in result
-        assert "ext_code_dirs" in result
-        assert "glossary_dir" in result
-        assert "Warning: unknown_key is not recognized as a valid configuration option." in mock_stdout.getvalue()
-
-    def test_handle_no_unrecognized_keys(self):
-        data = {
-            "ext_code_dirs": [],
-            "glossary_dir": "./glossary"
-        }
-        known_fields = {"ext_code_dirs", "glossary_dir"}
-        
-        result = handle_unrecognized_keys(data, known_fields)
-        assert result == data
-
-
-class TestFixLLMTemperatures:
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_fix_invalid_temperature_too_high(self, mock_stdout):
-        data = {
-            "llm_config": {
-                "gpt-4o": {
-                    "temperature": 1.5
-                }
-            }
-        }
-        
-        result = fix_llm_temperatures(data)
-        
-        assert result["llm_config"]["gpt-4o"]["temperature"] == 0.8
-        assert "Warning: Temperature for model 'gpt-4o' is outside the 0.0 to 1.0 range" in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_fix_invalid_temperature_too_low(self, mock_stdout):
-        data = {
-            "llm_config": {
-                "gpt-4o": {
-                    "temperature": -0.5
-                }
-            }
-        }
-        
-        result = fix_llm_temperatures(data)
+    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 result["llm_config"]["gpt-4o"]["temperature"] == 0.8
-        assert "Warning: Temperature for model 'gpt-4o' is outside the 0.0 to 1.0 range" in mock_stdout.getvalue()
-
-    def test_valid_temperature_not_changed(self):
-        data = {
-            "llm_config": {
-                "gpt-4o": {
-                    "temperature": 0.7
-                }
-            }
-        }
-        
-        result = fix_llm_temperatures(data)
-        assert result["llm_config"]["gpt-4o"]["temperature"] == 0.7
+        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()
 
-    def test_no_llm_config(self):
-        data = {"other_field": "value"}
-        result = fix_llm_temperatures(data)
-        assert result == data
-
-
-class TestValidateAndFixConfigData:
     @patch('sys.stdout', new_callable=StringIO)
-    @patch("builtins.open")
-    def test_valid_json_with_unrecognized_keys(self, mock_file, mock_stdout, valid_config_dict):
-        valid_config_dict["unknown_key"] = "value"
-        mock_file.return_value = mock_open(read_data=json.dumps(valid_config_dict))()
-        
-        result = validate_and_fix_config_data("config.json")
+    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 "unknown_key" not in result
-        assert "ext_code_dirs" in result
-        assert "Warning: unknown_key is not recognized as a valid configuration option." in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch("builtins.open", mock_open(read_data="invalid json"))
-    def test_invalid_json(self, mock_stdout):
-        result = validate_and_fix_config_data("config.json")
-        
-        assert result == {}
-        assert "Error: Invalid JSON in configuration file:" in mock_stdout.getvalue()
-        assert "Creating new configuration with defaults..." in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch("builtins.open", side_effect=IOError("File not found"))
-    def test_file_read_error(self, mock_file, mock_stdout):
-        result = validate_and_fix_config_data("config.json")
-        
-        assert result == {}
-        assert "Error reading configuration file: File not found" in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch("builtins.open")
-    def test_fix_invalid_temperatures(self, mock_file, mock_stdout, valid_config_dict):
-        valid_config_dict["llm_config"]["gpt-4o"]["temperature"] = 2.0
-        mock_file.return_value = mock_open(read_data=json.dumps(valid_config_dict))()
-        
-        result = validate_and_fix_config_data("config.json")
-        
-        assert result["llm_config"]["gpt-4o"]["temperature"] == 0.8
-        assert "Warning: Temperature for model 'gpt-4o' is outside the 0.0 to 1.0 range" in mock_stdout.getvalue()
+        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(self, mock_file, default_config_data):
+    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")
-        # Check that json.dump was called with correct data
         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
 
 
@@ -322,26 +186,53 @@ class TestReadData:
     @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_does_not_exist_creates_default(self, mock_exists, mock_ensure_dir, mock_save, mock_stdout):
+    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()  # Clear cache
+            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()
-        assert "ara-cli configuration file 'config.json' created with default configuration." in mock_stdout.getvalue()
+        
+        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_file_exists_valid_config(self, mock_exists, mock_ensure_dir, mock_file, mock_save, valid_config_dict):
-        mock_file.return_value = mock_open(read_data=json.dumps(valid_config_dict))()
-        read_data.cache_clear()  # Clear cache
+    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)
@@ -349,95 +240,97 @@ class TestReadData:
     @patch('builtins.open')
     @patch('ara_cli.ara_config.ensure_directory_exists')
     @patch('ara_cli.ara_config.exists', return_value=True)
-    def test_file_exists_with_validation_error(self, mock_exists, mock_ensure_dir, mock_file, 
-                                             mock_save, mock_stdout, corrupted_config_dict):
-        mock_file.return_value = mock_open(read_data=json.dumps(corrupted_config_dict))()
-        read_data.cache_clear()  # Clear cache
+    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()
-        # Check for any error message related to type conversion
-        assert ("Error reading configuration file:" in output or 
-               "ValidationError:" in output)
-        mock_save.assert_called()
+        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_preserve_valid_fields_on_error(self, mock_exists, mock_ensure_dir, mock_file, 
-                                          mock_save, mock_stdout):
-        partial_valid_config = {
-            "glossary_dir": "./custom/glossary",
-            "ext_code_dirs": "invalid",  # This will cause validation error
-            "doc_dir": "./custom/docs"
+    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()
         
-        mock_file.return_value = mock_open(read_data=json.dumps(partial_valid_config))()
-        read_data.cache_clear()  # Clear cache
-        
+        defaults = ARAconfig()
         result = read_data("config.json")
-        
-        # The implementation actually preserves the invalid value
-        # This is the actual behavior based on the error message
-        assert isinstance(result, ARAconfig)
-        assert result.ext_code_dirs == "invalid"  # The invalid value is preserved
-        assert result.glossary_dir == "./custom/glossary"
-        assert result.doc_dir == "./custom/docs"
-        
+
+        assert result.glossary_dir == "./my-custom-glossary"
+        assert result.default_llm == defaults.default_llm
+
         output = mock_stdout.getvalue()
-        assert "ValidationError:" in output
-        assert "Correcting configuration with default values..." in output
+        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_singleton(self, mock_read):
-        mock_config = MagicMock(spec=ARAconfig)
-        mock_read.return_value = mock_config
+    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)
         
-        # First call
         config1 = ConfigManager.get_config()
-        assert config1 == mock_config
-        mock_read.assert_called_once()
-        
-        # Second call should return cached instance
         config2 = ConfigManager.get_config()
-        assert config2 == config1
-        mock_read.assert_called_once()  # Still only called once
+        
+        assert config1 is config2
+        mock_read.assert_called_once()
 
     @patch('ara_cli.ara_config.read_data')
-    @patch('ara_cli.ara_config.makedirs')
-    @patch('ara_cli.ara_config.exists', return_value=False)
-    def test_get_config_creates_directory_if_not_exists(self, mock_exists, mock_makedirs, mock_read):
+    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("./custom/config.json")
-        mock_makedirs.assert_called_once_with("./custom")
 
-    @patch('ara_cli.ara_config.read_data')
-    def test_reset(self, mock_read):
-        mock_config = MagicMock(spec=ARAconfig)
-        mock_read.return_value = mock_config
-        
-        # Get config
-        config1 = ConfigManager.get_config()
-        assert ConfigManager._config_instance is not None
+        ConfigManager.get_config()
+        mock_read.assert_called_once()
         
-        # Reset
         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_custom_filepath(self, mock_read):
-        custom_path = "./custom/ara_config.json"
-        mock_config = MagicMock(spec=ARAconfig)
-        mock_read.return_value = mock_config
+    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)
         
-        config = ConfigManager.get_config(custom_path)
-        mock_read.assert_called_once_with(custom_path)
-        assert config == mock_config
+        mock_read.assert_called_once_with(custom_path)

tests/test_prompt_handler.py

@@ -0,0 +1,303 @@
+import pytest
+import os
+import shutil
+import base64
+from unittest.mock import patch, MagicMock, mock_open, call
+from pathlib import Path
+
+from ara_cli import prompt_handler
+from ara_cli.ara_config import ARAconfig, LLMConfigItem
+
+@pytest.fixture
+def mock_config():
+    """Mocks a standard ARAconfig object for testing."""
+    config = ARAconfig(
+        ext_code_dirs=[{"source_dir": "./src"}],
+        glossary_dir="./glossary",
+        doc_dir="./docs",
+        local_prompt_templates_dir="./ara/.araconfig",
+        custom_prompt_templates_subdir="custom-prompt-modules",
+        ara_prompt_given_list_includes=["*.py"],
+        llm_config={
+            "gpt-4o": LLMConfigItem(provider="openai", model="openai/gpt-4o", temperature=0.8, max_tokens=1024),
+            "o3-mini": LLMConfigItem(provider="openai", model="openai/o3-mini", temperature=0.9, max_tokens=2048),
+        },
+        default_llm="gpt-4o"
+    )
+    return config
+
+@pytest.fixture
+def mock_config_manager(mock_config):
+    """Patches ConfigManager to ensure it always returns the mock_config."""
+    with patch('ara_cli.ara_config.ConfigManager.get_config') as mock_get_config:
+        mock_get_config.return_value = mock_config
+        yield mock_get_config
+
+@pytest.fixture(autouse=True)
+def reset_singleton():
+    """Resets the LLMSingleton before each test for isolation."""
+    prompt_handler.LLMSingleton._instance = None
+    prompt_handler.LLMSingleton._model = None
+    yield
+
+class TestLLMSingleton:
+    """Tests the behavior of the LLMSingleton class."""
+
+    def test_get_instance_creates_with_default_model(self, mock_config_manager):
+        instance = prompt_handler.LLMSingleton.get_instance()
+        assert instance is not None
+        assert prompt_handler.LLMSingleton.get_model() == "gpt-4o"
+        assert instance.config_parameters['temperature'] == 0.8
+
+    def test_get_instance_creates_with_first_model_if_no_default(self, mock_config_manager, mock_config):
+        mock_config.default_llm = None
+        instance = prompt_handler.LLMSingleton.get_instance()
+        assert instance is not None
+        assert prompt_handler.LLMSingleton.get_model() == "gpt-4o"
+
+    def test_get_instance_returns_same_instance(self, mock_config_manager):
+        instance1 = prompt_handler.LLMSingleton.get_instance()
+        instance2 = prompt_handler.LLMSingleton.get_instance()
+        assert instance1 is instance2
+
+    def test_set_model_switches_model(self, mock_config_manager):
+        initial_instance = prompt_handler.LLMSingleton.get_instance()
+        assert prompt_handler.LLMSingleton.get_model() == "gpt-4o"
+        
+        with patch('builtins.print') as mock_print:
+            new_instance = prompt_handler.LLMSingleton.set_model("o3-mini")
+            mock_print.assert_called_with("Language model switched to 'o3-mini'")
+
+        assert prompt_handler.LLMSingleton.get_model() == "o3-mini"
+        assert new_instance.config_parameters['temperature'] == 0.9
+        assert initial_instance is not new_instance
+
+    def test_set_model_to_invalid_raises_error(self, mock_config_manager):
+        with pytest.raises(ValueError, match="No configuration found for the model: invalid-model"):
+            prompt_handler.LLMSingleton.set_model("invalid-model")
+
+    def test_get_model_initializes_if_needed(self, mock_config_manager):
+        assert prompt_handler.LLMSingleton._instance is None
+        model = prompt_handler.LLMSingleton.get_model()
+        assert model == "gpt-4o"
+        assert prompt_handler.LLMSingleton._instance is not None
+
+class TestFileIO:
+    """Tests file I/O helper functions."""
+
+    def test_write_and_read_string_from_file(self, tmp_path):
+        file_path = tmp_path / "test.txt"
+        test_string = "Hello World"
+        
+        prompt_handler.write_string_to_file(file_path, test_string, 'w')
+        
+        content = prompt_handler.read_string_from_file(file_path)
+        assert test_string in content
+        
+        content_get = prompt_handler.get_file_content(file_path)
+        assert content == content_get
+
+
+class TestCoreLogic:
+    """Tests functions related to the main business logic."""
+
+    @patch('ara_cli.prompt_handler.litellm.completion')
+    @patch('ara_cli.prompt_handler.LLMSingleton.get_instance')
+    def test_send_prompt(self, mock_get_instance, mock_completion, mock_config):
+        mock_llm_instance = MagicMock()
+        mock_llm_instance.config_parameters = mock_config.llm_config['gpt-4o'].model_dump()
+        mock_get_instance.return_value = mock_llm_instance
+        
+        mock_chunk = MagicMock()
+        mock_chunk.choices[0].delta.content = "test chunk"
+        mock_completion.return_value = [mock_chunk]
+
+        prompt = [{"role": "user", "content": "A test"}]
+        
+        result = list(prompt_handler.send_prompt(prompt))
+
+        expected_params = mock_config.llm_config['gpt-4o'].model_dump(exclude_none=True)
+        del expected_params['provider']
+
+        mock_completion.assert_called_once_with(
+            messages=prompt,
+            stream=True,
+            **expected_params
+        )
+        assert len(result) == 1
+        assert result[0].choices[0].delta.content == "test chunk"
+
+    @patch('ara_cli.prompt_handler.send_prompt')
+    def test_describe_image(self, mock_send_prompt, tmp_path):
+        fake_image_path = tmp_path / "test.png"
+        fake_image_content = b"fakeimagedata"
+        fake_image_path.write_bytes(fake_image_content)
+        
+        mock_send_prompt.return_value = iter([])
+        
+        prompt_handler.describe_image(fake_image_path)
+        
+        mock_send_prompt.assert_called_once()
+        called_args = mock_send_prompt.call_args[0][0]
+        
+        assert len(called_args) == 1
+        message_content = called_args[0]['content']
+        assert isinstance(message_content, list)
+        assert message_content[0]['type'] == 'text'
+        assert message_content[1]['type'] == 'image_url'
+        
+        encoded_image = base64.b64encode(fake_image_content).decode('utf-8')
+        expected_url = f"data:image/png;base64,{encoded_image}"
+        assert message_content[1]['image_url']['url'] == expected_url
+
+    @patch('ara_cli.prompt_handler.Classifier.get_sub_directory', return_value="test_classifier")
+    def test_append_headings(self, mock_get_sub, tmp_path):
+        os.chdir(tmp_path)
+        os.makedirs("ara/test_classifier/my_param.data", exist_ok=True)
+        
+        log_file = tmp_path / "ara/test_classifier/my_param.data/test_classifier.prompt_log.md"
+        
+        prompt_handler.append_headings("test_classifier", "my_param", "PROMPT")
+        assert "## PROMPT_1" in log_file.read_text()
+        
+        prompt_handler.append_headings("test_classifier", "my_param", "PROMPT")
+        assert "## PROMPT_2" in log_file.read_text()
+        
+        prompt_handler.append_headings("test_classifier", "my_param", "RESULT")
+        assert "## RESULT_1" in log_file.read_text()
+
+class TestArtefactAndTemplateHandling:
+    """Tests functions that manage artefact and template files."""
+
+    @pytest.fixture(autouse=True)
+    def setup_fs(self, tmp_path):
+        self.root = tmp_path
+        os.chdir(self.root)
+        self.mock_classifier = "my_artefact"
+        self.mock_param = "my_param"
+        
+        self.classifier_patch = patch('ara_cli.prompt_handler.Classifier.get_sub_directory', return_value=self.mock_classifier)
+        self.mock_get_sub_dir = self.classifier_patch.start()
+        
+        yield
+        
+        self.classifier_patch.stop()
+
+    def test_prompt_data_directory_creation(self):
+        path = prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param)
+        expected_path = self.root / "ara" / self.mock_classifier / f"{self.mock_param}.data" / "prompt.data"
+        assert os.path.exists(expected_path)
+        assert Path(path).resolve() == expected_path.resolve()
+
+    @patch('ara_cli.prompt_handler.generate_markdown_listing')
+    def test_generate_config_prompt_givens_file(self, mock_generate_listing, mock_config_manager):
+        prompt_data_path = prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param)
+        
+        prompt_handler.generate_config_prompt_givens_file(prompt_data_path, "config.givens.md")
+        
+        mock_generate_listing.assert_called_once()
+        args, _ = mock_generate_listing.call_args
+        assert "ara" in args[0]
+        assert "./src" in args[0]
+        assert "./docs" in args[0]
+        assert "./glossary" in args[0]
+        assert args[1] == ["*.py"]
+        assert args[2] == os.path.join(prompt_data_path, "config.givens.md")
+
+    @patch('ara_cli.prompt_handler.generate_markdown_listing')
+    def test_generate_config_prompt_givens_file_marks_artefact(self, mock_generate_listing, mock_config_manager):
+        prompt_data_path = Path(prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param))
+        config_path = prompt_data_path / "config.givens.md"
+        artefact_to_mark = "file.py"
+
+        def create_fake_file(*args, **kwargs):
+            content = f"- [] some_other_file.txt\n- [] {artefact_to_mark}\n"
+            with open(args[2], 'w') as f:
+                f.write(content)
+
+        mock_generate_listing.side_effect = create_fake_file
+
+        prompt_handler.generate_config_prompt_givens_file(
+            str(prompt_data_path), "config.givens.md", artefact_to_mark=artefact_to_mark
+        )
+        
+        content = config_path.read_text()
+        assert f"- [x] {artefact_to_mark}" in content
+        assert f"- [] some_other_file.txt" in content
+
+    @patch('ara_cli.prompt_handler.extract_and_load_markdown_files')
+    @patch('ara_cli.prompt_handler.move_and_copy_files')
+    @patch('ara_cli.prompt_handler.TemplatePathManager.get_template_base_path', return_value="/global/templates")
+    def test_load_selected_prompt_templates(self, mock_base_path, mock_move, mock_extract, mock_config_manager):
+        prompt_data_path = prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param)
+        config_file = Path(prompt_data_path) / "config.prompt_templates.md"
+        config_file.touch()
+
+        mock_extract.return_value = [
+            "custom-prompt-modules/my_custom.rules.md",
+            "prompt-modules/global.intention.md",
+            "unrecognized/file.md"
+        ]
+        
+        prompt_handler.load_selected_prompt_templates(self.mock_classifier, self.mock_param)
+
+        archive_path = os.path.join(prompt_data_path, "prompt.archive")
+
+        assert mock_move.call_count == 2
+        expected_calls = [
+            call(
+                os.path.join(mock_config_manager.return_value.local_prompt_templates_dir, "custom-prompt-modules/my_custom.rules.md"),
+                prompt_data_path,
+                archive_path
+            ),
+            call(
+                os.path.join("/global/templates", "prompt-modules/global.intention.md"),
+                prompt_data_path,
+                archive_path
+            )
+        ]
+        mock_move.assert_has_calls(expected_calls, any_order=True)
+
+    def test_extract_and_load_markdown_files(self):
+        md_content = """
+# prompt-modules
+## a-category
+- [x] first.rules.md
+- [] second.rules.md
+# custom-prompt-modules
+- [x] custom.intention.md
+"""
+        m = mock_open(read_data=md_content)
+        with patch('builtins.open', m):
+            paths = prompt_handler.extract_and_load_markdown_files("dummy_path")
+        
+        assert len(paths) == 2
+        assert 'prompt-modules/a-category/first.rules.md' in paths
+        assert 'custom-prompt-modules/custom.intention.md' in paths
+    
+    @patch('ara_cli.prompt_handler.send_prompt')
+    @patch('ara_cli.prompt_handler.collect_file_content_by_extension')
+    @patch('ara_cli.prompt_handler.append_images_to_message')
+    def test_create_and_send_custom_prompt(self, mock_append_images, mock_collect, mock_send):
+        prompt_data_path = Path(prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param))
+
+        mock_collect.return_value = ("### GIVENS\ncontent", [{"type": "image_url", "image_url": {}}])
+        
+        final_message_list = [{"role": "user", "content": [{"type": "text", "text": "### GIVENS\ncontent"}, {"type": "image_url", "image_url": {}}]}]
+        mock_append_images.return_value = final_message_list
+
+        mock_send.return_value = iter([MagicMock(choices=[MagicMock(delta=MagicMock(content="llm response"))])])
+
+        prompt_handler.create_and_send_custom_prompt(self.mock_classifier, self.mock_param)
+        
+        mock_collect.assert_called_once()
+        mock_append_images.assert_called_once()
+        mock_send.assert_called_once_with(final_message_list)
+
+        artefact_root = self.root / "ara" / self.mock_classifier
+        log_file = artefact_root / f"{self.mock_param}.data" / f"{self.mock_classifier}.prompt_log.md"
+
+        assert log_file.exists()
+        log_content = log_file.read_text()
+        assert "### GIVENS\ncontent" in log_content
+        assert "llm response" in log_content