ara-cli 0.1.13.3__py3-none-any.whl → 0.1.14.0__py3-none-any.whl

tests/test_prompt_handler.py

@@ -16,22 +16,24 @@ from langfuse.api.resources.commons.errors import NotFoundError
 @pytest.fixture(autouse=True)
 def mock_langfuse():
     """Mock Langfuse client to prevent network calls during tests."""
-    with patch.object(prompt_handler.LLMSingleton, 'langfuse', None):
+    with patch.object(prompt_handler.LLMSingleton, "langfuse", None):
         mock_langfuse_instance = MagicMock()
-        
+
         # Mock the get_prompt method to raise NotFoundError (simulating prompt not found)
         mock_langfuse_instance.get_prompt.side_effect = NotFoundError(
-            # status_code=404, 
-            body={'message': "Prompt not found", 'error': 'LangfuseNotFoundError'}
+            # status_code=404,
+            body={"message": "Prompt not found", "error": "LangfuseNotFoundError"}
         )
-        
+
         # Mock the span context manager
         mock_span = MagicMock()
         mock_span.__enter__ = MagicMock(return_value=mock_span)
         mock_span.__exit__ = MagicMock(return_value=None)
         mock_langfuse_instance.start_as_current_span.return_value = mock_span
-        
-        with patch.object(prompt_handler.LLMSingleton, 'langfuse', mock_langfuse_instance):
+
+        with patch.object(
+            prompt_handler.LLMSingleton, "langfuse", mock_langfuse_instance
+        ):
             yield mock_langfuse_instance
 
 
@@ -45,11 +47,21 @@ def mock_config():
         local_prompt_templates_dir="./ara/.araconfig/custom-prompt-modules",
         ara_prompt_given_list_includes=["*.py", "*.md"],
         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),
+            "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",
-        extraction_llm="o3-mini"
+        extraction_llm="o3-mini",
     )
     return config
 
@@ -57,7 +69,7 @@ def mock_config():
 @pytest.fixture(autouse=True)
 def mock_config_manager(mock_config):
     """Patches ConfigManager to ensure it always returns the mock_config."""
-    with patch.object(ConfigManager, 'get_config') as mock_get_config:
+    with patch.object(ConfigManager, "get_config") as mock_get_config:
         mock_get_config.return_value = mock_config
         yield mock_get_config
 
@@ -81,30 +93,44 @@ class TestLLMSingleton:
         assert instance is not None
         assert prompt_handler.LLMSingleton.get_default_model() == "gpt-4o"
         assert prompt_handler.LLMSingleton.get_extraction_model() == "o3-mini"
-        assert instance.default_config_params['temperature'] == 0.8
-        assert instance.extraction_config_params['temperature'] == 0.9
+        assert instance.default_config_params["temperature"] == 0.8
+        assert instance.extraction_config_params["temperature"] == 0.9
 
-    def test_get_instance_creates_with_first_model_if_no_default(self, mock_config_manager, mock_config):
+    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_default_model() == "gpt-4o"
 
-    def test_get_instance_no_extraction_llm_falls_back_to_default(self, mock_config_manager, mock_config):
+    def test_get_instance_no_extraction_llm_falls_back_to_default(
+        self, mock_config_manager, mock_config
+    ):
         mock_config.extraction_llm = None
         instance = prompt_handler.LLMSingleton.get_instance()
         assert instance is not None
         assert prompt_handler.LLMSingleton.get_extraction_model() == "gpt-4o"
 
-    def test_get_instance_no_llm_config_raises_error(self, mock_config_manager, mock_config):
+    def test_get_instance_no_llm_config_raises_error(
+        self, mock_config_manager, mock_config
+    ):
         mock_config.llm_config = {}
         mock_config.default_llm = None  # This is crucial to hit the correct check
-        with pytest.raises(ValueError, match="No LLM configurations are defined in the configuration file."):
+        with pytest.raises(
+            ValueError,
+            match="No LLM configurations are defined in the configuration file.",
+        ):
             prompt_handler.LLMSingleton.get_instance()
 
-    def test_get_instance_constructor_raises_for_missing_extraction_config(self, mock_config_manager, mock_config):
+    def test_get_instance_constructor_raises_for_missing_extraction_config(
+        self, mock_config_manager, mock_config
+    ):
         mock_config.extraction_llm = "missing-model"
-        with pytest.raises(ValueError, match="No configuration found for the extraction model: missing-model"):
+        with pytest.raises(
+            ValueError,
+            match="No configuration found for the extraction model: missing-model",
+        ):
             prompt_handler.LLMSingleton.get_instance()
 
     def test_get_instance_returns_same_instance(self, mock_config_manager):
@@ -113,19 +139,21 @@ class TestLLMSingleton:
         assert instance1 is instance2
 
     def test_get_config_by_purpose(self, mock_config_manager):
-        default_params = prompt_handler.LLMSingleton.get_config_by_purpose('default')
-        extraction_params = prompt_handler.LLMSingleton.get_config_by_purpose('extraction')
-        assert default_params['model'] == 'openai/gpt-4o'
-        assert extraction_params['model'] == 'openai/o3-mini'
+        default_params = prompt_handler.LLMSingleton.get_config_by_purpose("default")
+        extraction_params = prompt_handler.LLMSingleton.get_config_by_purpose(
+            "extraction"
+        )
+        assert default_params["model"] == "openai/gpt-4o"
+        assert extraction_params["model"] == "openai/o3-mini"
 
     def test_set_default_model_switches_model(self, mock_config_manager):
         initial_instance = prompt_handler.LLMSingleton.get_instance()
         assert prompt_handler.LLMSingleton.get_default_model() == "gpt-4o"
-        
+
         new_instance = prompt_handler.LLMSingleton.set_default_model("o3-mini")
 
         assert prompt_handler.LLMSingleton.get_default_model() == "o3-mini"
-        assert new_instance.default_config_params['temperature'] == 0.9
+        assert new_instance.default_config_params["temperature"] == 0.9
         assert initial_instance is not new_instance
 
     def test_set_default_model_to_same_model_does_nothing(self, mock_config_manager):
@@ -134,14 +162,17 @@ class TestLLMSingleton:
         assert instance1 is instance2
 
     def test_set_default_model_to_invalid_raises_error(self, mock_config_manager):
-        with pytest.raises(ValueError, match="No configuration found for the default model: invalid-model"):
+        with pytest.raises(
+            ValueError,
+            match="No configuration found for the default model: invalid-model",
+        ):
             prompt_handler.LLMSingleton.set_default_model("invalid-model")
 
     def test_set_extraction_model_switches_model(self, mock_config_manager):
         initial_instance = prompt_handler.LLMSingleton.get_instance()
         new_instance = prompt_handler.LLMSingleton.set_extraction_model("gpt-4o")
         assert prompt_handler.LLMSingleton.get_extraction_model() == "gpt-4o"
-        assert new_instance.extraction_config_params['temperature'] == 0.8
+        assert new_instance.extraction_config_params["temperature"] == 0.8
         assert initial_instance is not new_instance
 
     def test_set_extraction_model_to_same_model_does_nothing(self, mock_config_manager):
@@ -150,7 +181,10 @@ class TestLLMSingleton:
         assert instance1 is instance2
 
     def test_set_extraction_model_to_invalid_raises_error(self, mock_config_manager):
-        with pytest.raises(ValueError, match="No configuration found for the extraction model: invalid-model"):
+        with pytest.raises(
+            ValueError,
+            match="No configuration found for the extraction model: invalid-model",
+        ):
             prompt_handler.LLMSingleton.set_extraction_model("invalid-model")
 
     def test_get_default_model_initializes_if_needed(self, mock_config_manager):
@@ -172,12 +206,12 @@ class TestFileIO:
     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')
-        
+
+        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.strip() == test_string
 
@@ -192,7 +226,7 @@ class TestFileIO:
 
 class TestCoreLogic:
     """Tests functions related to the main business logic."""
-    
+
     @pytest.fixture(autouse=True)
     def setup_test_env(self, tmp_path):
         """Changes CWD to a temporary directory for test isolation."""
@@ -201,43 +235,63 @@ class TestCoreLogic:
         yield
         os.chdir(original_cwd)
 
-    @pytest.mark.parametrize("message, expected", [
-        ({"content": "Hello"}, True),
-        ({"content": "  "}, False),
-        ({"content": ""}, False),
-        ({"content": "\n\t"}, False),
-        ({"content": [{"type": "text", "text": " "}]}, False),
-        ({"content": [{"type": "text", "text": "Valid text"}]}, True),
-        ({"content": [{"type": "image_url"}, {"type": "text", "text": "More text"}]}, True),
-        ({"content": []}, False),
-        ({"content": 123}, False),
-        ({}, False),
-    ])
+    @pytest.mark.parametrize(
+        "message, expected",
+        [
+            ({"content": "Hello"}, True),
+            ({"content": "  "}, False),
+            ({"content": ""}, False),
+            ({"content": "\n\t"}, False),
+            ({"content": [{"type": "text", "text": " "}]}, False),
+            ({"content": [{"type": "text", "text": "Valid text"}]}, True),
+            (
+                {
+                    "content": [
+                        {"type": "image_url"},
+                        {"type": "text", "text": "More text"},
+                    ]
+                },
+                True,
+            ),
+            ({"content": []}, False),
+            ({"content": 123}, False),
+            ({}, False),
+        ],
+    )
     def test_is_valid_message(self, message, expected):
         assert prompt_handler._is_valid_message(message) == expected
 
-    @patch('ara_cli.prompt_handler.litellm.completion')
-    def test_send_prompt(self, mock_completion, mock_config, mock_config_manager):
+    @patch("ara_cli.prompt_handler._get_litellm")
+    def test_send_prompt(self, mock_get_litellm, mock_config, mock_config_manager):
         """Tests that send_prompt uses the default LLM by default."""
+        mock_litellm = MagicMock()
+        mock_get_litellm.return_value = mock_litellm
+
         mock_chunk = MagicMock()
         mock_chunk.choices[0].delta.content = "test chunk"
-        mock_completion.return_value = [mock_chunk]
+        mock_litellm.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']
+        expected_params = mock_config.llm_config["gpt-4o"].model_dump(exclude_none=True)
+        del expected_params["provider"]
 
-        mock_completion.assert_called_once_with(
+        mock_litellm.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.litellm.completion')
-    def test_send_prompt_filters_invalid_messages(self, mock_completion, mock_config_manager):
+    @patch("ara_cli.prompt_handler._get_litellm")
+    def test_send_prompt_filters_invalid_messages(
+        self, mock_get_litellm, mock_config_manager
+    ):
+        mock_litellm = MagicMock()
+        mock_get_litellm.return_value = mock_litellm
+        mock_litellm.completion.return_value = []
+
         prompt = [
             {"role": "user", "content": "Valid message"},
             {"role": "user", "content": " "},
@@ -247,53 +301,62 @@ class TestCoreLogic:
 
         list(prompt_handler.send_prompt(prompt))
 
-        mock_completion.assert_called_once()
-        called_args = mock_completion.call_args[1]
-        assert called_args['messages'] == valid_prompt
+        mock_litellm.completion.assert_called_once()
+        called_args = mock_litellm.completion.call_args[1]
+        assert called_args["messages"] == valid_prompt
 
-    @patch('ara_cli.prompt_handler.litellm.completion')
-    def test_send_prompt_uses_extraction_llm(self, mock_completion, mock_config, mock_config_manager):
+    @patch("ara_cli.prompt_handler._get_litellm")
+    def test_send_prompt_uses_extraction_llm(
+        self, mock_get_litellm, mock_config, mock_config_manager
+    ):
         """Tests that send_prompt uses the extraction LLM when specified."""
-        mock_completion.return_value = []
+        mock_litellm = MagicMock()
+        mock_get_litellm.return_value = mock_litellm
+        mock_litellm.completion.return_value = []
+
         prompt = [{"role": "user", "content": "Extract this"}]
-        
-        list(prompt_handler.send_prompt(prompt, purpose='extraction'))
 
-        expected_params = mock_config.llm_config['o3-mini'].model_dump(exclude_none=True)
-        del expected_params['provider']
+        list(prompt_handler.send_prompt(prompt, purpose="extraction"))
+
+        expected_params = mock_config.llm_config["o3-mini"].model_dump(
+            exclude_none=True
+        )
+        del expected_params["provider"]
 
-        mock_completion.assert_called_once_with(
+        mock_litellm.completion.assert_called_once_with(
             messages=prompt, stream=True, **expected_params
         )
 
-    @patch('ara_cli.prompt_handler.send_prompt')
+    @patch("ara_cli.prompt_handler.send_prompt")
     def test_describe_image(self, mock_send_prompt, tmp_path, mock_langfuse):
         fake_image_path = tmp_path / "test.jpeg"
         fake_image_content = b"fakeimagedata"
         fake_image_path.write_bytes(fake_image_content)
-        
+
         mock_send_prompt.return_value = iter([])
-        
+
         # Ensure the langfuse mock is properly set up for this instance
         instance = prompt_handler.LLMSingleton.get_instance()
         instance.langfuse = mock_langfuse
-        
+
         prompt_handler.describe_image(fake_image_path)
-        
+
         mock_send_prompt.assert_called_once()
         called_args, called_kwargs = mock_send_prompt.call_args
-        
-        assert called_kwargs == {'purpose': 'extraction'}
-        message_content = called_args[0][0]['content']
-        assert message_content[0]['type'] == 'text'
-        assert message_content[1]['type'] == 'image_url'
-        
-        encoded_image = base64.b64encode(fake_image_content).decode('utf-8')
+
+        assert called_kwargs == {"purpose": "extraction"}
+        message_content = called_args[0][0]["content"]
+        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/jpeg;base64,{encoded_image}"
-        assert message_content[1]['image_url']['url'] == expected_url
+        assert message_content[1]["image_url"]["url"] == expected_url
 
-    @patch('ara_cli.prompt_handler.send_prompt')
-    def test_describe_image_returns_response_text(self, mock_send_prompt, tmp_path, mock_langfuse):
+    @patch("ara_cli.prompt_handler.send_prompt")
+    def test_describe_image_returns_response_text(
+        self, mock_send_prompt, tmp_path, mock_langfuse
+    ):
         fake_image_path = tmp_path / "test.gif"
         fake_image_path.touch()
 
@@ -302,7 +365,7 @@ class TestCoreLogic:
         mock_chunk2 = MagicMock()
         mock_chunk2.choices[0].delta.content = "a description."
         mock_chunk3 = MagicMock()
-        mock_chunk3.choices[0].delta.content = None # Test empty chunk
+        mock_chunk3.choices[0].delta.content = None  # Test empty chunk
         mock_send_prompt.return_value = iter([mock_chunk1, mock_chunk3, mock_chunk2])
 
         # Ensure the langfuse mock is properly set up for this instance
@@ -312,48 +375,65 @@ class TestCoreLogic:
         description = prompt_handler.describe_image(fake_image_path)
         assert description == "This is a description."
 
-    @patch('ara_cli.prompt_handler.Classifier.get_sub_directory', return_value="test_classifier")
+    @patch(
+        "ara_cli.prompt_handler.Classifier.get_sub_directory",
+        return_value="test_classifier",
+    )
     def test_append_headings(self, mock_get_sub, 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"
+        log_file = (
+            tmp_path / "ara/test_classifier/my_param.data/test_classifier.prompt_log.md"
+        )
         log_file.touch()
 
         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()
 
-    @patch('ara_cli.prompt_handler.Classifier.get_sub_directory', return_value="test_classifier")
+    @patch(
+        "ara_cli.prompt_handler.Classifier.get_sub_directory",
+        return_value="test_classifier",
+    )
     def test_append_headings_creates_file_if_not_exists(self, mock_get_sub, 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"
+        log_file = (
+            tmp_path / "ara/test_classifier/my_param.data/test_classifier.prompt_log.md"
+        )
         assert not log_file.exists()
 
         prompt_handler.append_headings("test_classifier", "my_param", "HEADING")
         assert log_file.exists()
         assert "## HEADING_1" in log_file.read_text()
 
-    @patch('ara_cli.prompt_handler.Classifier.get_sub_directory', return_value="test_classifier")
+    @patch(
+        "ara_cli.prompt_handler.Classifier.get_sub_directory",
+        return_value="test_classifier",
+    )
     def test_write_prompt_result(self, mock_get_sub, 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"
+        log_file = (
+            tmp_path / "ara/test_classifier/my_param.data/test_classifier.prompt_log.md"
+        )
 
-        prompt_handler.write_prompt_result("test_classifier", "my_param", "Test content")
+        prompt_handler.write_prompt_result(
+            "test_classifier", "my_param", "Test content"
+        )
         assert "Test content" in log_file.read_text()
 
     def test_prepend_system_prompt(self, mock_langfuse):
         # Ensure the langfuse mock is properly set up for this instance
         instance = prompt_handler.LLMSingleton.get_instance()
         instance.langfuse = mock_langfuse
-        
+
         messages = [{"role": "user", "content": "Hi"}]
         result = prompt_handler.prepend_system_prompt(messages)
         assert len(result) == 2
-        assert result[0]['role'] == 'system'
-        assert result[1]['role'] == 'user'
+        assert result[0]["role"] == "system"
+        assert result[1]["role"] == "user"
 
-    @patch('logging.getLogger')
+    @patch("logging.getLogger")
     def test_append_images_to_message_logic(self, mock_get_logger):
         # Test case 1: No images, should return original message
         message_no_img = {"role": "user", "content": "Hello"}
@@ -366,16 +446,19 @@ class TestCoreLogic:
         result = prompt_handler.append_images_to_message(message_with_text, images)
         expected_content = [
             {"type": "text", "text": "Describe these."},
-            {"type": "image_url", "image_url": {"url": "data:..."}}
+            {"type": "image_url", "image_url": {"url": "data:..."}},
         ]
         assert result["content"] == expected_content
-        
+
         # Test case 3: Add images to an existing list content
-        message_with_list = {"role": "user", "content": [{"type": "text", "text": "Initial text."}]}
+        message_with_list = {
+            "role": "user",
+            "content": [{"type": "text", "text": "Initial text."}],
+        }
         result = prompt_handler.append_images_to_message(message_with_list, images)
         expected_content_2 = [
             {"type": "text", "text": "Initial text."},
-            {"type": "image_url", "image_url": {"url": "data:..."}}
+            {"type": "image_url", "image_url": {"url": "data:..."}},
         ]
         assert result["content"] == expected_content_2
 
@@ -394,9 +477,9 @@ class TestFileOperations:
         (base_path / "rules").mkdir(parents=True)
         (base_path / "rules" / "b.rules.md").touch()
         (base_path / "rules" / "a.rules.md").touch()
-        
+
         m = mock_open()
-        with patch('builtins.open', m):
+        with patch("builtins.open", m):
             prompt_handler.write_template_files_to_config("rules", m(), str(base_path))
 
         # Check that files were written in sorted order with correct spacing
@@ -429,29 +512,39 @@ class TestFileOperations:
 
         source_file = source_dir / "new.rules.md"
         source_file.write_text("new rules")
-        
+
         existing_file = prompt_data / "old.rules.md"
         existing_file.write_text("old rules")
 
         unrelated_source = source_dir / "unrelated.txt"
         unrelated_source.touch()
-        
+
         missing_source = source_dir / "nonexistent.rules.md"
-        
-        with patch('builtins.print') as mock_print:
+
+        with patch("builtins.print") as mock_print:
             # Test move and copy
-            prompt_handler.move_and_copy_files(str(source_file), str(prompt_data), str(prompt_archive))
+            prompt_handler.move_and_copy_files(
+                str(source_file), str(prompt_data), str(prompt_archive)
+            )
             assert not existing_file.exists()
             assert (prompt_archive / "old.rules.md").exists()
             assert (prompt_data / "new.rules.md").read_text() == "new rules"
-            
+
             # Test skipping unrelated files
-            prompt_handler.move_and_copy_files(str(unrelated_source), str(prompt_data), str(prompt_archive))
-            assert mock_print.call_args_list[-1] == call("File name unrelated.txt does not end with one of the specified patterns, skipping move and copy.")
-            
+            prompt_handler.move_and_copy_files(
+                str(unrelated_source), str(prompt_data), str(prompt_archive)
+            )
+            assert mock_print.call_args_list[-1] == call(
+                "File name unrelated.txt does not end with one of the specified patterns, skipping move and copy."
+            )
+
             # Test warning for missing source
-            prompt_handler.move_and_copy_files(str(missing_source), str(prompt_data), str(prompt_archive))
-            assert mock_print.call_args_list[-1] == call(f"WARNING: template {missing_source} does not exist.")
+            prompt_handler.move_and_copy_files(
+                str(missing_source), str(prompt_data), str(prompt_archive)
+            )
+            assert mock_print.call_args_list[-1] == call(
+                f"WARNING: template {missing_source} does not exist."
+            )
 
     def test_extract_and_load_markdown_files_complex_hierarchy(self):
         md_content = """
@@ -468,29 +561,29 @@ class TestFileOperations:
 - [x] l1_again.md
 """
         m = mock_open(read_data=md_content)
-        with patch('builtins.open', m):
+        with patch("builtins.open", m):
             paths = prompt_handler.extract_and_load_markdown_files("dummy_path")
-        
+
         expected = [
-            'L1/l1.md',
-            'L1/L2-A/l2a.md',
-            'L1/L2-A/L3/l3.md',
-            'L1/L2-B/l2b.md',
-            'L1-Again/l1_again.md',
+            "L1/l1.md",
+            "L1/L2-A/l2a.md",
+            "L1/L2-A/L3/l3.md",
+            "L1/L2-B/l2b.md",
+            "L1-Again/l1_again.md",
         ]
         assert paths == expected
 
-    @patch('ara_cli.prompt_handler.get_partial_file_content')
-    @patch('ara_cli.prompt_handler.get_file_content')
+    @patch("ara_cli.prompt_handler.get_partial_file_content")
+    @patch("ara_cli.prompt_handler.get_file_content")
     def test_load_givens(self, mock_get_content, mock_get_partial, tmp_path):
         # Setup files
         md_config = tmp_path / "config.givens.md"
         text_file = tmp_path / "file.txt"
         image_file = tmp_path / "image.png"
-        
+
         text_file.write_text("Full content")
         image_file.write_bytes(b"imagedata")
-        
+
         md_content = f"""
 # src
 - [x] {text_file}
@@ -503,11 +596,16 @@ class TestFileOperations:
         # Mocks
         mock_get_content.return_value = "Full content"
         mock_get_partial.return_value = "Partial content"
-        
+
         # Execute
-        with patch('ara_cli.prompt_handler.extract_and_load_markdown_files', return_value=[str(text_file), f"[1:2] {text_file}", str(image_file)]):
-             # The regex in load_givens is flawed, so we manually mock the extracted items
-            match = re.match(r".*?\[(\d+:\d+(?:,\s*\d+:\d+)*)\]\s+(.+)", f"[1:2] {text_file}")
+        with patch(
+            "ara_cli.prompt_handler.extract_and_load_markdown_files",
+            return_value=[str(text_file), f"[1:2] {text_file}", str(image_file)],
+        ):
+            # The regex in load_givens is flawed, so we manually mock the extracted items
+            match = re.match(
+                r".*?\[(\d+:\d+(?:,\s*\d+:\d+)*)\]\s+(.+)", f"[1:2] {text_file}"
+            )
             assert match is not None
 
             content, image_data = prompt_handler.load_givens(str(md_config))
@@ -519,27 +617,35 @@ class TestFileOperations:
         mock_get_partial.assert_called_once_with(str(text_file), "1:2")
 
         assert len(image_data) == 1
-        assert image_data[0]['type'] == 'image_url'
+        assert image_data[0]["type"] == "image_url"
         encoded = base64.b64encode(b"imagedata").decode("utf-8")
-        assert encoded in image_data[0]['image_url']['url']
+        assert encoded in image_data[0]["image_url"]["url"]
         assert f"![{image_file}](data:image/png;base64,{encoded})" in content
 
-    @patch('ara_cli.prompt_handler.load_givens')
-    @patch('ara_cli.prompt_handler.get_file_content')
-    @patch('ara_cli.prompt_handler.find_files_with_endings')
+    @patch("ara_cli.prompt_handler.load_givens")
+    @patch("ara_cli.prompt_handler.get_file_content")
+    @patch("ara_cli.prompt_handler.find_files_with_endings")
     def test_collect_file_content_by_extension(self, mock_find, mock_get, mock_load):
         prompt_data_path = "/fake/path"
         mock_find.side_effect = [["rules.rules.md"], ["givens.prompt_givens.md"]]
         mock_get.return_value = "Rules content"
         mock_load.return_value = ("Givens content", ["image_data"])
-        
+
         extensions = [".rules.md", ".prompt_givens.md"]
-        content, images = prompt_handler.collect_file_content_by_extension(prompt_data_path, extensions)
+        content, images = prompt_handler.collect_file_content_by_extension(
+            prompt_data_path, extensions
+        )
+
+        mock_find.assert_has_calls(
+            [call(prompt_data_path, [ext]) for ext in extensions]
+        )
+        mock_get.assert_called_once_with(
+            os.path.join(prompt_data_path, "rules.rules.md")
+        )
+        mock_load.assert_called_once_with(
+            os.path.join(prompt_data_path, "givens.prompt_givens.md")
+        )
 
-        mock_find.assert_has_calls([call(prompt_data_path, [ext]) for ext in extensions])
-        mock_get.assert_called_once_with(os.path.join(prompt_data_path, "rules.rules.md"))
-        mock_load.assert_called_once_with(os.path.join(prompt_data_path, "givens.prompt_givens.md"))
-        
         assert "Rules content" in content
         assert "Givens content" in content
         assert images == ["image_data"]
@@ -554,23 +660,36 @@ class TestArtefactAndTemplateHandling:
         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.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"
+        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')
-    @patch('ara_cli.prompt_handler.ArtefactCreator')
-    def test_initialize_prompt_templates(self, mock_artefact_creator, mock_generate_listing, mock_config_manager):
+    @patch("ara_cli.prompt_handler.generate_markdown_listing")
+    @patch("ara_cli.prompt_handler.ArtefactCreator")
+    def test_initialize_prompt_templates(
+        self, mock_artefact_creator, mock_generate_listing, mock_config_manager
+    ):
         # This side effect creates the file that the function expects to read
         def create_dummy_file(*args, **kwargs):
             file_path = args[2]
@@ -578,21 +697,35 @@ class TestArtefactAndTemplateHandling:
             Path(file_path).touch()
 
         mock_generate_listing.side_effect = create_dummy_file
-        
-        prompt_handler.initialize_prompt_templates(self.mock_classifier, self.mock_param)
-        
-        prompt_data_path = self.root / "ara" / self.mock_classifier / f"{self.mock_param}.data" / "prompt.data"
+
+        prompt_handler.initialize_prompt_templates(
+            self.mock_classifier, self.mock_param
+        )
+
+        prompt_data_path = (
+            self.root
+            / "ara"
+            / self.mock_classifier
+            / f"{self.mock_param}.data"
+            / "prompt.data"
+        )
         prompt_log_path = prompt_data_path.parent
 
         mock_artefact_creator.return_value.create_artefact_prompt_files.assert_called_once()
         assert mock_generate_listing.call_count == 2
 
-
-    @patch('ara_cli.prompt_handler.generate_markdown_listing')
-    def test_generate_config_prompt_template_file(self, mock_generate_listing, mock_config_manager):
+    @patch("ara_cli.prompt_handler.generate_markdown_listing")
+    def test_generate_config_prompt_template_file(
+        self, mock_generate_listing, mock_config_manager
+    ):
         prompt_data_path = "prompt/data"
-        with patch('ara_cli.prompt_handler.TemplatePathManager.get_template_base_path', return_value="/global/templates"):
-            prompt_handler.generate_config_prompt_template_file(prompt_data_path, "config.md")
+        with patch(
+            "ara_cli.prompt_handler.TemplatePathManager.get_template_base_path",
+            return_value="/global/templates",
+        ):
+            prompt_handler.generate_config_prompt_template_file(
+                prompt_data_path, "config.md"
+            )
 
         mock_generate_listing.assert_called_once()
         args, _ = mock_generate_listing.call_args
@@ -601,12 +734,18 @@ class TestArtefactAndTemplateHandling:
         assert "*.blueprint.md" in args[1]
         assert args[2] == os.path.join(prompt_data_path, "config.md")
 
-    @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")
-        
+    @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]
@@ -614,15 +753,21 @@ class TestArtefactAndTemplateHandling:
         assert args[1] == ["*.py", "*.md"]
         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))
+    @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:
+            with open(args[2], "w") as f:
                 f.write(content)
 
         mock_generate_listing.side_effect = create_fake_file
@@ -630,117 +775,174 @@ class TestArtefactAndTemplateHandling:
         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)
+    @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"
+            "unrecognized/file.md",
         ]
-        
-        with patch('builtins.print') as mock_print:
-            prompt_handler.load_selected_prompt_templates(self.mock_classifier, self.mock_param)
+
+        with patch("builtins.print") as mock_print:
+            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
-        mock_print.assert_any_call("WARNING: Unrecognized template type for item unrecognized/file.md.")
+        mock_print.assert_any_call(
+            "WARNING: Unrecognized template type for item unrecognized/file.md."
+        )
 
     def test_load_selected_prompt_templates_no_config_file_warns_and_returns(self):
-        prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param)
-        
-        with patch('builtins.print') as mock_print:
-            prompt_handler.load_selected_prompt_templates(self.mock_classifier, self.mock_param)
-        
-        mock_print.assert_called_once_with("WARNING: config.prompt_templates.md does not exist.")
-
-    @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', side_effect=lambda msg, img: msg) # Passthrough
-    def test_create_and_send_custom_prompt_handles_empty_chunks(self, mock_append, mock_collect, mock_send, tmp_path):
+        prompt_handler.prompt_data_directory_creation(
+            self.mock_classifier, self.mock_param
+        )
+
+        with patch("builtins.print") as mock_print:
+            prompt_handler.load_selected_prompt_templates(
+                self.mock_classifier, self.mock_param
+            )
+
+        mock_print.assert_called_once_with(
+            "WARNING: config.prompt_templates.md does not exist."
+        )
+
+    @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",
+        side_effect=lambda msg, img: msg,
+    )  # Passthrough
+    def test_create_and_send_custom_prompt_handles_empty_chunks(
+        self, mock_append, mock_collect, mock_send, tmp_path
+    ):
         # Create the directory structure the function expects
-        prompt_data_path = Path(f"ara/{self.mock_classifier}/{self.mock_param}.data/prompt.data")
+        prompt_data_path = Path(
+            f"ara/{self.mock_classifier}/{self.mock_param}.data/prompt.data"
+        )
         prompt_data_path.mkdir(parents=True, exist_ok=True)
 
         mock_collect.return_value = ("Test Content", [])
-        
+
         mock_chunk_ok = MagicMock()
         mock_chunk_ok.choices[0].delta.content = "response"
         mock_chunk_empty = MagicMock()
         mock_chunk_empty.choices[0].delta.content = None
         mock_send.return_value = iter([mock_chunk_empty, mock_chunk_ok])
 
-        log_file = tmp_path / "ara" / self.mock_classifier / f"{self.mock_param}.data" / f"{self.mock_classifier}.prompt_log.md"
+        log_file = (
+            tmp_path
+            / "ara"
+            / self.mock_classifier
+            / f"{self.mock_param}.data"
+            / f"{self.mock_classifier}.prompt_log.md"
+        )
         log_file.touch()
 
-        prompt_handler.create_and_send_custom_prompt(self.mock_classifier, self.mock_param)
+        prompt_handler.create_and_send_custom_prompt(
+            self.mock_classifier, self.mock_param
+        )
 
         log_content = log_file.read_text()
         assert "response" in log_content
         assert "None" not in log_content
 
-    @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, mock_config_manager):
-        prompt_handler.prompt_data_directory_creation(self.mock_classifier, self.mock_param)
+    @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, mock_config_manager
+    ):
+        prompt_handler.prompt_data_directory_creation(
+            self.mock_classifier, self.mock_param
+        )
 
         mock_collect.return_value = ("### GIVENS\ncontent", [{"type": "image_url"}])
-        
+
         # append_images_to_message returns a single dict, not a list of dicts.
-        returned_message_dict = {'role': 'user', 'content': ['### GIVENS\ncontent', {'type': 'image_url'}]}
+        returned_message_dict = {
+            "role": "user",
+            "content": ["### GIVENS\ncontent", {"type": "image_url"}],
+        }
         mock_append_images.return_value = returned_message_dict
 
-        mock_send.return_value = iter([MagicMock(choices=[MagicMock(delta=MagicMock(content="llm response"))])])
+        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
+        )
 
-        prompt_handler.create_and_send_custom_prompt(self.mock_classifier, self.mock_param)
-        
         mock_collect.assert_called_once()
 
         # Assert that append_images_to_message was called with a single dict (the bug fix)
         mock_append_images.assert_called_once_with(
-            {'role': 'user', 'content': '### GIVENS\ncontent'},
-            [{'type': 'image_url'}]
+            {"role": "user", "content": "### GIVENS\ncontent"}, [{"type": "image_url"}]
         )
 
         # Assert that send_prompt was called with a list containing the dict returned from append_images_to_message
         mock_send.assert_called_once_with([returned_message_dict])
 
-        log_file = self.root / "ara" / self.mock_classifier / f"{self.mock_param}.data" / f"{self.mock_classifier}.prompt_log.md"
+        log_file = (
+            self.root
+            / "ara"
+            / self.mock_classifier
+            / f"{self.mock_param}.data"
+            / f"{self.mock_classifier}.prompt_log.md"
+        )
         assert "llm response" in log_file.read_text()
 
-    @patch('ara_cli.global_file_lister.generate_global_markdown_listing')
-    def test_generate_config_prompt_global_givens_file(self, mock_global_lister, mock_config_manager, mock_config):
+    @patch("ara_cli.global_file_lister.generate_global_markdown_listing")
+    def test_generate_config_prompt_global_givens_file(
+        self, mock_global_lister, mock_config_manager, mock_config
+    ):
         """Tests that the global givens file is generated correctly when global_dirs are present."""
         prompt_data_path = self.root / "prompt/data"
         prompt_data_path.mkdir(parents=True)
-        
+
         # Scenario 1: No global_dirs are configured, should return early and do nothing.
         mock_config.global_dirs = []
-        prompt_handler.generate_config_prompt_global_givens_file(str(prompt_data_path), "global.md")
+        prompt_handler.generate_config_prompt_global_givens_file(
+            str(prompt_data_path), "global.md"
+        )
         mock_global_lister.assert_not_called()
-        
+
         # Scenario 2: With global_dirs, should call the global lister with correct arguments.
-        mock_config.global_dirs = [{"source_dir": "/global/src1"}, {"path": "/global/src2"}]
+        mock_config.global_dirs = [
+            {"source_dir": "/global/src1"},
+            {"path": "/global/src2"},
+        ]
         mock_config.ara_prompt_given_list_includes = ["*.py", "*.md"]
-        
+
         # Use patch to suppress print output during the test
-        with patch('builtins.print'):
-            prompt_handler.generate_config_prompt_global_givens_file(str(prompt_data_path), "global.md")
-        
+        with patch("builtins.print"):
+            prompt_handler.generate_config_prompt_global_givens_file(
+                str(prompt_data_path), "global.md"
+            )
+
         mock_global_lister.assert_called_once()
         args, _ = mock_global_lister.call_args
         assert args[0] == ["/global/src1", "/global/src2"]
         assert args[1] == ["*.py", "*.md"]
-        assert args[2] == os.path.join(prompt_data_path, "global.md")
+        assert args[2] == os.path.join(prompt_data_path, "global.md")