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

tests/test_setup_default_chat_prompt_mode.py

@@ -0,0 +1,198 @@
+import os
+import tempfile
+from unittest.mock import patch, MagicMock
+import pytest
+from ara_cli.prompt_chat import initialize_prompt_chat_mode
+from ara_cli.classifier import Classifier
+
+
+class TestSetupDefaultCombinedChatPromptMode:
+    """
+    Tests mirroring the scenarios in Setup_Default_Combined_Chat_Prompt_Mode.feature.
+    """
+
+    @pytest.fixture
+    def setup_ara_environment(self):
+        """Sets up a temporary directory structure mimicking the ara project."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Change to tmpdir to ensure relative paths work if used
+            cwd = os.getcwd()
+            os.chdir(tmpdir)
+
+            # Setup base directories
+            os.makedirs(os.path.join(tmpdir, "ara", "tasks"), exist_ok=True)
+
+            yield tmpdir
+
+            os.chdir(cwd)
+
+    @patch("ara_cli.prompt_chat.update_artefact_config_prompt_files")
+    @patch("ara_cli.chat.Chat.start", autospec=True)
+    @patch("ara_cli.chat.Chat.start_non_interactive", autospec=True)
+    @patch("ara_cli.prompt_handler.ConfigManager.get_config")
+    def test_scenario_1_start_prompt_chat_no_existing_file(
+        self,
+        mock_get_config,
+        mock_start_non_interactive,
+        mock_start,
+        mock_update_config,
+        setup_ara_environment,
+    ):
+        """
+        Scenario: Start prompt-chat mode with existing prompt.data directory and no existing default chat file.
+        Expectation: task_chat.md is created.
+        """
+        root_dir = setup_ara_environment
+        task_name = "123_chat_test"
+        classifier = "task"
+
+        # Mock config to avoid loading real config
+        mock_config = MagicMock()
+        mock_config.llm_config = [{"provider": "openai", "model": "gpt-4"}]
+        mock_get_config.return_value = mock_config
+
+        # Simulate directory creation normally handled by update_artefact_config_prompt_files
+        data_dir = os.path.join(root_dir, "ara", "tasks", f"{task_name}.data")
+        os.makedirs(data_dir, exist_ok=True)
+
+        # Execute
+        initialize_prompt_chat_mode(
+            classifier=classifier,
+            param=task_name,
+            chat_name=None,  # Default to classifier name 'task' -> 'task_chat.md'
+            reset=None,
+        )
+
+        # check paths
+        # Classifier.get_sub_directory('task') -> 'tasks'
+        # Path: ara/tasks/123_chat_test.data/task_chat.md  (Chat adds _chat.md suffix if missing)
+        expected_chat_path = os.path.join(
+            root_dir, "ara", "tasks", f"{task_name}.data", "task_chat.md"
+        )
+
+        assert os.path.exists(
+            expected_chat_path
+        ), f"Chat file not created at {expected_chat_path}"
+
+        with open(expected_chat_path, "r") as f:
+            content = f.read()
+        assert "# ara prompt:" in content
+
+        # Verify update config called
+        mock_update_config.assert_called_once()
+
+    @patch("ara_cli.prompt_chat.update_artefact_config_prompt_files")
+    @patch("ara_cli.chat.Chat.start", autospec=True)
+    @patch("ara_cli.chat.Chat.start_non_interactive", autospec=True)
+    @patch("ara_cli.prompt_handler.ConfigManager.get_config")
+    @patch("sys.stdin.readline", return_value="y\n")  # Simulate user typing 'y'
+    @patch("sys.stdout.write")  # Capture stdout to check prompt
+    def test_scenario_2_reset_existing_chat(
+        self,
+        mock_stdout,
+        mock_stdin,
+        mock_get_config,
+        mock_start_non_interactive,
+        mock_start,
+        mock_update_config,
+        setup_ara_environment,
+    ):
+        """
+        Scenario: Start prompt-chat mode with existing chat file, choose to reset.
+        Expectation: User prompted, file content reset.
+        """
+        root_dir = setup_ara_environment
+        task_name = "123_chat_test"
+        classifier = "task"
+
+        # Setup existing file
+        data_dir = os.path.join(root_dir, "ara", "tasks", f"{task_name}.data")
+        os.makedirs(data_dir, exist_ok=True)
+        chat_path = os.path.join(data_dir, "task_chat.md")
+
+        with open(chat_path, "w") as f:
+            f.write("# ara prompt:\nOld Content")
+
+        # Mock config
+        mock_config = MagicMock()
+        mock_config.llm_config = [{"provider": "openai", "model": "gpt-4"}]
+        mock_get_config.return_value = mock_config
+
+        # Execute
+        initialize_prompt_chat_mode(
+            classifier=classifier,
+            param=task_name,
+            chat_name=None,
+            reset=None,  # Should trigger interactive prompt
+        )
+
+        # Verify prompt was printed
+        # Note: sys.stdout.write is called by print()
+        # We check if any call args contained the prompt string
+        prompt_found = False
+        for call in mock_stdout.call_args_list:
+            if (
+                call.args
+                and "already exists. Do you want to reset the chat?" in call.args[0]
+            ):
+                prompt_found = True
+                break
+        # Alternatively, 'print' might use the buffer directly, but patching sys.stdout should catch it if flush=True/end="" usage in chat.py matches.
+        # chat.py: print(f"{chat_file_short} already exists. Do you want to reset the chat? (y/N): ", end="", flush=True)
+
+        # Since 'print' with end="" calls stdout.write, this should work.
+        # However, verifying strict output in mock might be tricky if not captured perfectly.
+        # Focusing on the RESULT (file reset) is most important for Scenario logic.
+
+        with open(chat_path, "r") as f:
+            content = f.read()
+
+        assert content == "# ara prompt:\n", "Chat file should have been reset"
+        assert "Old Content" not in content
+
+    @patch("ara_cli.prompt_chat.update_artefact_config_prompt_files")
+    @patch("ara_cli.chat.Chat.start", autospec=True)
+    @patch("ara_cli.chat.Chat.start_non_interactive", autospec=True)
+    @patch("ara_cli.prompt_handler.ConfigManager.get_config")
+    @patch("sys.stdin.readline", return_value="n\n")  # Simulate user typing 'n'
+    def test_scenario_3_append_existing_chat(
+        self,
+        mock_stdin,
+        mock_get_config,
+        mock_start_non_interactive,
+        mock_start,
+        mock_update_config,
+        setup_ara_environment,
+    ):
+        """
+        Scenario: Start prompt-chat mode with existing chat file, choose to append.
+        Expectation: File content preserved.
+        """
+        root_dir = setup_ara_environment
+        task_name = "123_chat_test"
+        classifier = "task"
+
+        # Setup existing file
+        data_dir = os.path.join(root_dir, "ara", "tasks", f"{task_name}.data")
+        os.makedirs(data_dir, exist_ok=True)
+        chat_path = os.path.join(data_dir, "task_chat.md")
+
+        original_content = "# ara prompt:\nOld Content"
+        with open(chat_path, "w") as f:
+            f.write(original_content)
+
+        # Mock config
+        mock_config = MagicMock()
+        mock_config.llm_config = [{"provider": "openai", "model": "gpt-4"}]
+        mock_get_config.return_value = mock_config
+
+        # Execute
+        initialize_prompt_chat_mode(
+            classifier=classifier, param=task_name, chat_name=None, reset=None
+        )
+
+        # Verify content preserved
+        with open(chat_path, "r") as f:
+            content = f.read()
+
+        assert content == original_content, "Chat file content should be preserved"

tests/test_tag_extractor.py

@@ -7,61 +7,107 @@ from ara_cli.list_filter import ListFilter
 @pytest.fixture
 def artefact():
     """Fixture to create a mock artefact object."""
+
     class Artefact:
-        def __init__(self, tags, status, users, author="creator_unknown", path="dummy.md", content=""):
+        def __init__(
+            self,
+            tags,
+            status,
+            users,
+            author="creator_unknown",
+            path="dummy.md",
+            content="",
+        ):
             self.tags = tags
             self.status = status
             self.users = users
             self.author = author
             self.path = path
             self.content = content
+
     return Artefact
 
 
-@pytest.mark.parametrize("navigate_to_target, filtered_extra_column, list_filter, artefact_data, expected_tags", [
-    (
-        False, False, None,
-        {'artefacts': [
-            (['tag1', 'tag2'], 'in-progress', ['user1'], "creator_unknown"),
-            (['tag3'], 'done', ['user2'], "creator_unknown")
-        ]},
-        ['creator_unknown', 'done', 'in-progress', 'tag1', 'tag2', 'tag3', 'user_user1', 'user_user2']
-    ),
-    (
-        False, True, None,
-        {'artefacts': [
-            (['project_a', 'priority_high'], None, ['user1'], "creator_unknown"),
-            (['feature_x'], 'done', ['user2'], "creator_unknown")
-        ]},
-        ['project_a']
-    ),
-    (
-        False, False, ListFilter(include_tags=['kritik']),
-        {'artefacts': [
-            (['release', 'kritik'], 'review', ['dev1'], "creator_unknown"),
-            (['bugfix'], 'to-do', ['dev2'], "creator_unknown")
-        ]},
-        ['creator_unknown', 'kritik', 'release', 'review', 'user_dev1']
-    ),
-    (
-        True, False, None,
-        {'artefacts': [
-            (['tag3'], 'status2', ['user3'], "creator_unknown")
-        ]},
-        ['creator_unknown', 'status2', 'tag3', 'user_user3']
-    ),
-    (
-        False, False, None,
-        {'artefacts': []},
-        []
-    ),
-])
-@patch('ara_cli.artefact_reader.ArtefactReader')
-@patch('ara_cli.template_manager.DirectoryNavigator')
-def test_extract_tags(mock_directory_navigator, mock_artefact_reader, artefact, navigate_to_target, filtered_extra_column, list_filter, artefact_data, expected_tags):
-    mock_artefacts = {key: [artefact(
-        *data) for data in artefact_list] for key, artefact_list in artefact_data.items()}
-    mock_artefact_reader.read_artefacts.return_value = mock_artefacts
+@pytest.mark.parametrize(
+    "navigate_to_target, filtered_extra_column, list_filter, artefact_data, expected_tags",
+    [
+        (
+            False,
+            False,
+            None,
+            {
+                "artefacts": [
+                    (["tag1", "tag2"], "in-progress", ["user1"], "creator_unknown"),
+                    (["tag3"], "done", ["user2"], "creator_unknown"),
+                ]
+            },
+            [
+                "creator_unknown",
+                "done",
+                "in-progress",
+                "tag1",
+                "tag2",
+                "tag3",
+                "user_user1",
+                "user_user2",
+            ],
+        ),
+        (
+            False,
+            True,
+            None,
+            {
+                "artefacts": [
+                    (
+                        ["project_a", "priority_high"],
+                        None,
+                        ["user1"],
+                        "creator_unknown",
+                    ),
+                    (["feature_x"], "done", ["user2"], "creator_unknown"),
+                ]
+            },
+            ["project_a"],
+        ),
+        (
+            False,
+            False,
+            ListFilter(include_tags=["kritik"]),
+            {
+                "artefacts": [
+                    (["release", "kritik"], "review", ["dev1"], "creator_unknown"),
+                    (["bugfix"], "to-do", ["dev2"], "creator_unknown"),
+                ]
+            },
+            ["creator_unknown", "kritik", "release", "review", "user_dev1"],
+        ),
+        (
+            True,
+            False,
+            None,
+            {"artefacts": [(["tag3"], "status2", ["user3"], "creator_unknown")]},
+            ["creator_unknown", "status2", "tag3", "user_user3"],
+        ),
+        (False, False, None, {"artefacts": []}, []),
+    ],
+)
+@patch("ara_cli.artefact_reader.ArtefactReader")
+@patch("ara_cli.template_manager.DirectoryNavigator")
+def test_extract_tags(
+    mock_directory_navigator,
+    mock_artefact_reader,
+    artefact,
+    navigate_to_target,
+    filtered_extra_column,
+    list_filter,
+    artefact_data,
+    expected_tags,
+):
+    mock_artefacts = {
+        key: [artefact(*data) for data in artefact_list]
+        for key, artefact_list in artefact_data.items()
+    }
+    mock_artefact_reader.return_value.read_artefacts.return_value = mock_artefacts
 
     mock_navigator_instance = mock_directory_navigator.return_value
     mock_navigator_instance.navigate_to_target = MagicMock()
@@ -71,7 +117,7 @@ def test_extract_tags(mock_directory_navigator, mock_artefact_reader, artefact,
     result = tag_extractor.extract_tags(
         navigate_to_target=navigate_to_target,
         filtered_extra_column=filtered_extra_column,
-        list_filter=list_filter
+        list_filter=list_filter,
     )
 
     if navigate_to_target:
@@ -79,11 +125,11 @@ def test_extract_tags(mock_directory_navigator, mock_artefact_reader, artefact,
     else:
         mock_navigator_instance.navigate_to_target.assert_not_called()
 
-    mock_artefact_reader.read_artefacts.assert_called_once()
+    mock_artefact_reader.return_value.read_artefacts.assert_called_once()
 
     # Convert dictionary result to flat list for comparison
     actual_tags = []
     for group in result.values():
         actual_tags.extend(group)
-    
-    assert sorted(actual_tags) == sorted(expected_tags)
+
+    assert sorted(actual_tags) == sorted(expected_tags)

ara_cli/file_loaders/document_readers.py

@@ -1,233 +0,0 @@
-import os
-from abc import ABC, abstractmethod
-from typing import Tuple, Optional
-
-
-class DocumentReader(ABC):
-    """Abstract base class for document readers"""
-    
-    def __init__(self, file_path: str):
-        self.file_path = file_path
-        self.base_dir = os.path.dirname(file_path)
-    
-    @abstractmethod
-    def read(self, extract_images: bool = False) -> str:
-        """Read document and optionally extract images"""
-        pass
-    
-    def create_image_data_dir(self, extension_suffix: str) -> str:
-        """
-        Create data directory for images with file extension suffix to avoid conflicts.
-        
-        Returns:
-            str: Path to images directory
-        """
-        file_name_with_ext = os.path.splitext(os.path.basename(self.file_path))[0] + f"_{extension_suffix}"
-        data_dir = os.path.join(self.base_dir, f"{file_name_with_ext}.data")
-        images_dir = os.path.join(data_dir, "images")
-        if not os.path.exists(images_dir):
-            os.makedirs(images_dir)
-        return images_dir
-    
-    def save_and_describe_image(self, image_data: bytes, image_format: str, 
-                               save_dir: str, image_counter: int) -> Tuple[str, str]:
-        """
-        Save image data and get its description from LLM.
-        
-        Returns:
-            tuple: (relative_image_path, description)
-        """
-        from ara_cli.prompt_handler import describe_image
-        
-        # Save image
-        image_filename = f"{image_counter}.{image_format}"
-        image_path = os.path.join(save_dir, image_filename)
-        
-        with open(image_path, "wb") as image_file:
-            image_file.write(image_data)
-        
-        # Get image description from LLM
-        description = describe_image(image_path)
-        
-        # Get relative path
-        relative_image_path = os.path.relpath(image_path, self.base_dir)
-        
-        return relative_image_path, description
-
-
-class DocxReader(DocumentReader):
-    """Reader for DOCX files"""
-    
-    def read(self, extract_images: bool = False) -> str:
-        import docx
-        
-        doc = docx.Document(self.file_path)
-        text_content = '\n'.join(para.text for para in doc.paragraphs)
-        
-        if not extract_images:
-            return text_content
-        
-        from PIL import Image
-        import io
-        
-        # Create data directory for images
-        images_dir = self.create_image_data_dir("docx")
-        
-        # Extract and process images
-        image_descriptions = []
-        image_counter = 1
-        
-        for rel in doc.part.rels.values():
-            if "image" in rel.reltype:
-                image_data = rel.target_part.blob
-                
-                # Determine image format
-                image = Image.open(io.BytesIO(image_data))
-                image_format = image.format.lower()
-                
-                # Save and describe image
-                relative_path, description = self.save_and_describe_image(
-                    image_data, image_format, images_dir, image_counter
-                )
-                
-                # Add formatted description to list
-                image_description = f"\nImage: {relative_path}\n[{description}]\n"
-                image_descriptions.append(image_description)
-                
-                image_counter += 1
-        
-        # Combine text content with image descriptions
-        if image_descriptions:
-            text_content += "\n\n### Extracted Images\n" + "\n".join(image_descriptions)
-        
-        return text_content
-
-
-class PdfReader(DocumentReader):
-    """Reader for PDF files"""
-    
-    def read(self, extract_images: bool = False) -> str:
-        import pymupdf4llm
-        
-        if not extract_images:
-            return pymupdf4llm.to_markdown(self.file_path, write_images=False)
-        
-        import fitz  # PyMuPDF
-        
-        # Create images directory
-        images_dir = self.create_image_data_dir("pdf")
-        
-        # Extract text without images first
-        text_content = pymupdf4llm.to_markdown(self.file_path, write_images=False)
-        
-        # Extract and process images
-        doc = fitz.open(self.file_path)
-        image_descriptions = []
-        image_counter = 1
-        
-        for page_num, page in enumerate(doc):
-            image_list = page.get_images()
-            
-            for img_index, img in enumerate(image_list):
-                # Extract image
-                xref = img[0]
-                base_image = doc.extract_image(xref)
-                image_bytes = base_image["image"]
-                image_ext = base_image["ext"]
-                
-                # Save and describe image
-                relative_path, description = self.save_and_describe_image(
-                    image_bytes, image_ext, images_dir, image_counter
-                )
-                
-                # Add formatted description to list
-                image_description = f"\nImage: {relative_path}\n[{description}]\n"
-                image_descriptions.append(image_description)
-                
-                image_counter += 1
-        
-        doc.close()
-        
-        # Combine text content with image descriptions
-        if image_descriptions:
-            text_content += "\n\n### Extracted Images\n" + "\n".join(image_descriptions)
-        
-        return text_content
-
-
-class OdtReader(DocumentReader):
-    """Reader for ODT files"""
-    
-    def read(self, extract_images: bool = False) -> str:
-        import pymupdf4llm
-        
-        if not extract_images:
-            return pymupdf4llm.to_markdown(self.file_path, write_images=False)
-        
-        import zipfile
-        from PIL import Image
-        import io
-        
-        # Create data directory for images
-        images_dir = self.create_image_data_dir("odt")
-        
-        # Get text content
-        text_content = pymupdf4llm.to_markdown(self.file_path, write_images=False)
-        
-        # Extract and process images from ODT
-        image_descriptions = []
-        image_counter = 1
-        
-        try:
-            with zipfile.ZipFile(self.file_path, 'r') as odt_zip:
-                # List all files in the Pictures directory
-                picture_files = [f for f in odt_zip.namelist() if f.startswith('Pictures/')]
-                
-                for picture_file in picture_files:
-                    # Extract image data
-                    image_data = odt_zip.read(picture_file)
-                    
-                    # Determine image format
-                    image = Image.open(io.BytesIO(image_data))
-                    image_format = image.format.lower()
-                    
-                    # Save and describe image
-                    relative_path, description = self.save_and_describe_image(
-                        image_data, image_format, images_dir, image_counter
-                    )
-                    
-                    # Add formatted description to list
-                    image_description = f"\nImage: {relative_path}\n[{description}]\n"
-                    image_descriptions.append(image_description)
-                    
-                    image_counter += 1
-        except Exception as e:
-            print(f"Warning: Could not extract images from ODT: {e}")
-        
-        # Combine text content with image descriptions
-        if image_descriptions:
-            text_content += "\n\n### Extracted Images\n" + "\n".join(image_descriptions)
-        
-        return text_content
-
-
-class DocumentReaderFactory:
-    """Factory for creating appropriate document readers"""
-    
-    @staticmethod
-    def create_reader(file_path: str) -> Optional[DocumentReader]:
-        """Create appropriate reader based on file extension"""
-        _, ext = os.path.splitext(file_path)
-        ext = ext.lower()
-        
-        readers = {
-            '.docx': DocxReader,
-            '.pdf': PdfReader,
-            '.odt': OdtReader
-        }
-        
-        reader_class = readers.get(ext)
-        if reader_class:
-            return reader_class(file_path)
-        
-        return None