ara-cli 0.1.9.89__tar.gz → 0.1.9.92__tar.gz

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.89
+Version: 0.1.9.92
 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.89 → ara_cli-0.1.9.92}/ara_cli/ara_config.py

@@ -49,6 +49,11 @@ class ARAconfig(BaseModel):
             temperature=1,
             max_completion_tokens=16000
         ),
+        "gpt-5-mini": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-5-mini-2025-08-07",
+            temperature=1
+        ),
         "gpt-4o": LLMConfigItem(
             provider="openai",
             model="openai/gpt-4o",
@@ -92,11 +97,12 @@ class ARAconfig(BaseModel):
             max_tokens=4000
         )
     })
-    default_llm: Optional[str] = "gpt-5"
+    default_llm: Optional[str] = None
+    extraction_llm: Optional[str] = None
 
     @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 validate default_llm and extraction_llm."""
         critical_fields = {
             'ext_code_dirs': [{"source_dir": "./src"}, {"source_dir": "./tests"}],
             'local_ara_templates_dir': "./ara/.araconfig/templates/",
@@ -110,6 +116,30 @@ class ARAconfig(BaseModel):
                 print(f"Warning: Value for '{field}' is missing or empty. Using default.")
                 setattr(self, field, default_value)
         
+        if not self.llm_config:
+            print("Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set.")
+            self.default_llm = None
+            self.extraction_llm = None
+            return self
+
+        first_available_llm = next(iter(self.llm_config))
+
+        if not self.default_llm:
+            print(f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'.")
+            self.default_llm = first_available_llm
+        elif self.default_llm not in self.llm_config:
+            print(f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'.")
+            print(f"-> Reverting to the first available model: '{first_available_llm}'.")
+            self.default_llm = first_available_llm
+
+        if not self.extraction_llm:
+            print(f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'.")
+            self.extraction_llm = self.default_llm
+        elif self.extraction_llm not in self.llm_config:
+            print(f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'.")
+            print(f"-> Reverting to the 'default_llm' value: '{self.default_llm}'.")
+            self.extraction_llm = self.default_llm
+            
         return self
 
 # Function to ensure the necessary directories exist

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/ara_cli/chat.py

@@ -433,7 +433,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
                 break
 
         is_file_document = any(file_name_lower.endswith(ext)
-                               for ext in document_type_extensions)
+                                for ext in document_type_extensions)
 
         if is_file_document:
             return self.load_document_file(
@@ -532,7 +532,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         return [x for x in glob.glob(text + '*')]
 
     def _retrieve_ara_config(self):
-        from ara_cli.prompt_handler import ConfigManager
+        from ara_cli.ara_config import ConfigManager
         return ConfigManager().get_config()
 
     def _retrieve_llm_config(self):
@@ -625,7 +625,7 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     @cmd2.with_category(CATEGORY_LLM_CONTROL)
     def do_CHOOSE_MODEL(self, model_name):
         from ara_cli.prompt_handler import LLMSingleton
-        from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION, save_data
+        from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION, save_data, ConfigManager
         from ara_cli.directory_navigator import DirectoryNavigator
 
         original_dir = os.getcwd()
@@ -634,7 +634,11 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         os.chdir('..')
 
         if not self._verify_llm_choice(model_name):
+            os.chdir(original_dir)
             return
+
+        ConfigManager.reset()
+        self.config = ConfigManager.get_config()
         self.config.default_llm = model_name
         save_data(filepath=DEFAULT_CONFIG_LOCATION, config=self.config)
 
@@ -642,11 +646,48 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
 
         os.chdir(original_dir)
 
+    @cmd2.with_category(CATEGORY_LLM_CONTROL)
+    def do_CHOOSE_EXTRACTION_MODEL(self, model_name):
+        """Choose the language model for extraction tasks."""
+        from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION, save_data, ConfigManager
+        from ara_cli.directory_navigator import DirectoryNavigator
+
+        original_dir = os.getcwd()
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+        os.chdir('..')
+
+        if not self._verify_llm_choice(model_name):
+            os.chdir(original_dir)
+            return
+
+        ConfigManager.reset()
+        self.config = ConfigManager.get_config()
+        self.config.extraction_llm = model_name
+        save_data(filepath=DEFAULT_CONFIG_LOCATION, config=self.config)
+        print(f"Extraction model switched to '{model_name}'")
+
+        os.chdir(original_dir)
+
     @cmd2.with_category(CATEGORY_LLM_CONTROL)
     def do_CURRENT_MODEL(self, _):
-        from ara_cli.prompt_handler import LLMSingleton
+        """Displays the current default (reasoning) language model."""
+        from ara_cli.ara_config import ConfigManager
+
+        ConfigManager.reset()
+        config = self._retrieve_ara_config()
+        
+        print(config.default_llm)
 
-        print(LLMSingleton.get_model())
+    @cmd2.with_category(CATEGORY_LLM_CONTROL)
+    def do_CURRENT_EXTRACTION_MODEL(self, _):
+        """Displays the current extraction language model."""
+        from ara_cli.ara_config import ConfigManager
+
+        ConfigManager.reset()
+        config = self._retrieve_ara_config()
+        
+        print(config.extraction_llm)
 
     def _complete_llms(self, text, line, begidx, endidx):
         llm_config = self._retrieve_llm_config()
@@ -662,6 +703,9 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
     def complete_CHOOSE_MODEL(self, text, line, begidx, endidx):
         return self._complete_llms(text, line, begidx, endidx)
 
+    def complete_CHOOSE_EXTRACTION_MODEL(self, text, line, begidx, endidx):
+        return self._complete_llms(text, line, begidx, endidx)
+
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_NEW(self, chat_name):
         """Create a new chat. Optionally provide a chat name in-line: NEW new_chat"""
@@ -859,3 +903,95 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
             completions = [classifier for classifier in classifiers if classifier.startswith(text)]
 
         return completions
+
+
+    def _get_plural_template_type(self, template_type: str) -> str:
+        """Determines the plural form of a template type."""
+        plurals = {"commands": "commands", "rules": "rules"}
+        return plurals.get(template_type, f"{template_type}s")
+
+    def _find_project_root(self) -> str | None:
+        """
+        Finds the project root by searching for an 'ara' directory,
+        starting from the chat file's directory and moving upwards.
+        """
+        current_dir = os.path.dirname(self.chat_name)
+        while True:
+            if os.path.isdir(os.path.join(current_dir, 'ara')):
+                return current_dir
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached the filesystem root
+                return None
+            current_dir = parent_dir
+
+    def _gather_templates_from_path(self, search_path: str, templates_set: set, prefix: str = ""):
+        """
+        Scans a given path for items and adds them to the provided set,
+        optionally prepending a prefix.
+        """
+        import glob
+        if not os.path.isdir(search_path):
+            return
+        for path in glob.glob(os.path.join(search_path, '*')):
+            templates_set.add(f"{prefix}{os.path.basename(path)}")
+
+    def _get_available_templates(self, template_type: str) -> list[str]:
+        """
+        Scans for available global and project-local custom templates.
+        This method safely searches for template files without changing the
+        current directory, making it safe for use in autocompleters.
+
+        Args:
+            template_type: The type of template to search for (e.g., 'rules').
+
+        Returns:
+            A sorted list of unique template names. Global templates are
+            prefixed with 'global/'.
+        """
+        from ara_cli.template_manager import TemplatePathManager
+
+        plural_type = self._get_plural_template_type(template_type)
+        templates = set()
+
+        # 1. Find Global Templates
+        try:
+            global_base_path = TemplatePathManager.get_template_base_path()
+            global_template_dir = os.path.join(global_base_path, "prompt-modules", plural_type)
+            self._gather_templates_from_path(global_template_dir, templates, prefix="global/")
+        except Exception:
+            pass  # Silently ignore if global templates are not found
+
+        # 2. Find Local Custom Templates
+        try:
+            project_root = self._find_project_root()
+            if project_root:
+                local_templates_base = os.path.join(project_root, self.config.local_prompt_templates_dir)
+                custom_dir = os.path.join(local_templates_base, self.config.custom_prompt_templates_subdir, plural_type)
+                self._gather_templates_from_path(custom_dir, templates)
+        except Exception:
+            pass  # Silently ignore if local templates cannot be resolved
+
+        return sorted(list(templates))
+
+    def _template_completer(self, text: str, template_type: str) -> list[str]:
+        """Generic completer for different template types."""
+        available_templates = self._get_available_templates(template_type)
+        if not text:
+            return available_templates
+        return [t for t in available_templates if t.startswith(text)]
+
+    def complete_LOAD_RULES(self, text, line, begidx, endidx):
+        """Completer for the LOAD_RULES command."""
+        return self._template_completer(text, "rules")
+
+    def complete_LOAD_INTENTION(self, text, line, begidx, endidx):
+        """Completer for the LOAD_INTENTION command."""
+        return self._template_completer(text, "intention")
+
+    def complete_LOAD_COMMANDS(self, text, line, begidx, endidx):
+        """Completer for the LOAD_COMMANDS command."""
+        return self._template_completer(text, "commands")
+
+    def complete_LOAD_BLUEPRINT(self, text, line, begidx, endidx):
+        """Completer for the LOAD_BLUEPRINT command."""
+        return self._template_completer(text, "blueprint")

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/ara_cli/prompt_extractor.py

@@ -192,7 +192,7 @@ def handle_existing_file(filename, block_content, skip_query=False):
         messages = [{"role": "user", "content": prompt_text}]
         response = ""
 
-        for chunk in send_prompt(messages):
+        for chunk in send_prompt(messages, purpose='extraction'):
             content = chunk.choices[0].delta.content
             if content:
                 response += content

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/ara_cli/prompt_handler.py

@@ -71,29 +71,54 @@ def read_string_from_file(path):
         text = file.read()
     return text
 
+def _get_model_config(purpose: str) -> dict:
+    """
+    Resolves model ID by purpose and returns its prepared configuration for LiteLLM.
+    """
+    config = ConfigManager().get_config()
+
+    # Determine which model to use based on the purpose
+    model_id = config.default_llm
+    if purpose == 'extraction':
+        # Use extraction_llm if it exists, otherwise fall back to default_llm
+        model_id = getattr(config, 'extraction_llm', config.default_llm)
+
+    selected_config = config.llm_config.get(str(model_id))
+
+    if not selected_config:
+        raise ValueError(f"No configuration found for model '{model_id}' used for '{purpose}'")
+
+    config_parameters = selected_config.model_dump(exclude_none=True)
+    config_parameters.pop("provider", None)
+    
+    return config_parameters
+
+
+def _is_valid_message(message: dict) -> bool:
+    """
+    Checks if a message in a prompt is valid (i.e., not empty).
+    It handles both string content and list content (for multimodal inputs).
+    """
+    content = message.get('content')
+
+    if isinstance(content, str):
+        return content.strip() != ''
+    
+    if isinstance(content, list):
+        # For multimodal content, check if there's at least one non-empty text part.
+        return any(
+            item.get('type') == 'text' and item.get('text', '').strip() != ''
+            for item in content
+        )
+        
+    return False
+
+
+def send_prompt(prompt, purpose='default'):
+    """Prepares and sends a prompt to the LLM, streaming the response."""
+    config_parameters = _get_model_config(purpose)
 
-def send_prompt(prompt):
-    chat = LLMSingleton.get_instance()
-
-    config_parameters = chat.config_parameters.copy()
-    if "provider" in config_parameters:
-        del config_parameters["provider"]
-
-    filtered_prompt = list(filter(
-        lambda msg: (
-            msg.get('content') and
-            isinstance(msg['content'], list) and
-            any(
-                item.get('type') == 'text' and
-                item.get('text', '').strip() != ''
-                for item in msg['content']
-            )
-        ) or (
-            isinstance(msg.get('content'), str) and
-            msg['content'].strip() != ''
-        ),
-        prompt
-    ))
+    filtered_prompt = [msg for msg in prompt if _is_valid_message(msg)]
 
     completion = litellm.completion(
         **config_parameters,

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/ara_cli/version.py

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

{ara_cli-0.1.9.89 → ara_cli-0.1.9.92}/ara_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.89
+Version: 0.1.9.92
 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.89 → ara_cli-0.1.9.92}/tests/test_prompt_handler.py

@@ -6,7 +6,7 @@ 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
+from ara_cli.ara_config import ARAconfig, LLMConfigItem, ConfigManager
 
 @pytest.fixture
 def mock_config():
@@ -19,26 +19,30 @@ def mock_config():
         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, max_completion_tokens= None),
-            "o3-mini": LLMConfigItem(provider="openai", model="openai/o3-mini", temperature=0.9, max_tokens=2048, max_completion_tokens= None),
+            "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"
+        default_llm="gpt-4o",
+        extraction_llm="o3-mini"
     )
     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:
+    with patch.object(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."""
+    """Resets the LLMSingleton and ConfigManager before each test for isolation."""
     prompt_handler.LLMSingleton._instance = None
     prompt_handler.LLMSingleton._model = None
+    ConfigManager.reset()
     yield
+    ConfigManager.reset()
+
 
 class TestLLMSingleton:
     """Tests the behavior of the LLMSingleton class."""
@@ -100,14 +104,19 @@ 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."""
+        original_cwd = os.getcwd()
+        os.chdir(tmp_path)
+        yield
+        os.chdir(original_cwd)
+
 
     @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
-        
+    def test_send_prompt(self, mock_completion, mock_config, mock_config_manager):
+        """Tests that send_prompt uses the default LLM by default."""
         mock_chunk = MagicMock()
         mock_chunk.choices[0].delta.content = "test chunk"
         mock_completion.return_value = [mock_chunk]
@@ -116,9 +125,8 @@ class TestCoreLogic:
         
         result = list(prompt_handler.send_prompt(prompt))
 
-        # Create expected parameters to match the actual implementation
-        # The actual send_prompt function copies config_parameters and only removes 'provider'
-        expected_params = mock_config.llm_config['gpt-4o'].model_dump()
+        # Check that the parameters for the default model ('gpt-4o') were used
+        expected_params = mock_config.llm_config['gpt-4o'].model_dump(exclude_none=True)
         if 'provider' in expected_params:
             del expected_params['provider']
 
@@ -130,6 +138,29 @@ class TestCoreLogic:
         assert len(result) == 1
         assert result[0].choices[0].delta.content == "test chunk"
 
+    @patch('ara_cli.prompt_handler.litellm.completion')
+    def test_send_prompt_uses_extraction_llm(self, mock_completion, mock_config, mock_config_manager):
+        """Tests that send_prompt uses the extraction LLM when specified."""
+        mock_chunk = MagicMock()
+        mock_chunk.choices[0].delta.content = "extraction chunk"
+        mock_completion.return_value = [mock_chunk]
+        prompt = [{"role": "user", "content": "Extract this"}]
+        
+        # Call with the 'extraction' purpose
+        result = list(prompt_handler.send_prompt(prompt, purpose='extraction'))
+
+        # Check that the parameters for the extraction model ('o3-mini') were used
+        expected_params = mock_config.llm_config['o3-mini'].model_dump(exclude_none=True)
+        if 'provider' in expected_params:
+            del expected_params['provider']
+
+        mock_completion.assert_called_once_with(
+            messages=prompt,
+            stream=True,
+            **expected_params
+        )
+        assert result[0].choices[0].delta.content == "extraction 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"
@@ -155,11 +186,14 @@ class TestCoreLogic:
 
     @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)
+        # The autouse fixture already handles chdir, so we just use tmp_path for paths
         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"
         
+        # Create file first to avoid FileNotFoundError
+        log_file.touch()
+
         prompt_handler.append_headings("test_classifier", "my_param", "PROMPT")
         assert "## PROMPT_1" in log_file.read_text()
         
@@ -281,12 +315,15 @@ class TestArtefactAndTemplateHandling:
     @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):
+    def test_create_and_send_custom_prompt(self, mock_append_images, mock_collect, mock_send, mock_config_manager):
         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": {}}]}]
+        # The initial message list before appending images
+        initial_message_list = [{'role': 'user', 'content': '### GIVENS\ncontent'}]
+        # The final list after images are appended
+        final_message_list = [{'role': 'user', 'content': ['### 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"))])])
@@ -294,7 +331,8 @@ class TestArtefactAndTemplateHandling:
         prompt_handler.create_and_send_custom_prompt(self.mock_classifier, self.mock_param)
         
         mock_collect.assert_called_once()
-        mock_append_images.assert_called_once()
+        # The append function is called with the message list containing the text and the image data list
+        mock_append_images.assert_called_once_with([{'role': 'user', 'content': '### GIVENS\ncontent'}], [{'type': 'image_url', 'image_url': {}}])
         mock_send.assert_called_once_with(final_message_list)
 
         artefact_root = self.root / "ara" / self.mock_classifier