ara-cli 0.1.9.94__tar.gz → 0.1.9.95__tar.gz

{ara_cli-0.1.9.94 → ara_cli-0.1.9.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.94
+Version: 0.1.9.95
 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
@@ -13,6 +13,7 @@ Requires-Dist: json-repair
 Requires-Dist: argparse
 Requires-Dist: argcomplete
 Requires-Dist: cmd2>=2.5
+Requires-Dist: charset-normalizer
 Requires-Dist: pydantic
 Requires-Dist: pydantic_ai
 Requires-Dist: python-docx

ara_cli-0.1.9.95/ara_cli/__init__.py

@@ -0,0 +1,17 @@
+import warnings
+from .version import __version__
+
+
+whitelisted_commands = ["RERUN", "SEND", "EXTRACT", "LOAD_IMAGE", "CHOOSE_MODEL", "CHOOSE_EXTRACTION_MODEL", "CURRENT_MODEL", "CURRENT_EXTRACTION_MODEL", "LIST_MODELS"]
+
+
+# ANSI escape codes for coloring
+YELLOW = '\033[93m'
+RESET = '\033[0m'
+
+
+def format_warning(message, category, *args, **kwargs):
+    return f'{YELLOW}{category.__name__}: {message}{RESET}\n'
+
+
+warnings.formatwarning = format_warning

{ara_cli-0.1.9.94 → ara_cli-0.1.9.95}/ara_cli/ara_config.py

@@ -6,6 +6,7 @@ from os.path import exists, dirname
 from os import makedirs
 from functools import lru_cache
 import sys
+import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
@@ -21,6 +22,7 @@ class ARAconfig(BaseModel):
         {"source_dir": "./src"},
         {"source_dir": "./tests"}
     ])
+    global_dirs: Optional[List[Dict[str, str]]] = Field(default=[])
     glossary_dir: str = "./glossary"
     doc_dir: str = "./docs"
     local_prompt_templates_dir: str = "./ara/.araconfig"
@@ -162,6 +164,7 @@ def handle_unrecognized_keys(data: dict) -> dict:
             cleaned_data[key] = value
     return cleaned_data
 
+
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
@@ -170,6 +173,16 @@ def read_data(filepath: str) -> ARAconfig:
     If the file doesn't exist, it creates a default one.
     If the file is invalid, it corrects only the broken parts.
     """
+
+    def warn_on_duplicate_llm_dict_key(ordered_pairs):
+        """Reject duplicate keys."""
+        d = {}
+        for k, v in ordered_pairs:
+            if k in d:
+                warnings.warn(f"Duplicate LLM configuration identifier '{k}'. The previous entry will be removed.", UserWarning)
+            d[k] = v
+        return d
+
     ensure_directory_exists(dirname(filepath))
 
     if not exists(filepath):
@@ -181,7 +194,8 @@ def read_data(filepath: str) -> ARAconfig:
 
     try:
         with open(filepath, "r", encoding="utf-8") as file:
-            data = json.load(file)
+            content = file.read()
+            data = json.loads(content, object_pairs_hook=warn_on_duplicate_llm_dict_key)
     except json.JSONDecodeError as e:
         print(f"Error: Invalid JSON in configuration file: {e}")
         print("Creating a new configuration with defaults...")
@@ -206,7 +220,8 @@ def read_data(filepath: str) -> ARAconfig:
         
         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)
+            if field_name in corrected_data:
+                corrected_data[field_name] = defaults.get(field_name)
 
         print("--- End of Error Report ---")
 

{ara_cli-0.1.9.94 → ara_cli-0.1.9.95}/ara_cli/artefact_autofix.py

@@ -144,11 +144,11 @@ def run_agent(prompt, artefact_class):
     # anthropic:claude-4-sonnet-20250514
     agent = Agent(
         model="anthropic:claude-4-sonnet-20250514",
-        result_type=artefact_class,
+        output_type=artefact_class,
         instrument=True,
     )
     result = agent.run_sync(prompt)
-    return result.data
+    return result.output
 
 
 def write_corrected_artefact(file_path, corrected_text):
@@ -196,36 +196,52 @@ def ask_for_correct_contribution(
     return name, classifier
 
 
-def ask_for_contribution_choice(
-    choices, artefact_info: Optional[tuple[str, str]] = None
-) -> Optional[str]:
-    artefact_name, artefact_classifier = (
-        artefact_info if artefact_info else (None, None)
-    )
+def ask_for_contribution_choice(choices: List[str], artefact_info: Optional[tuple[str, str]] = None) -> Optional[str]:
+    artefact_name, artefact_classifier = artefact_info if artefact_info else (None, None)
     message = "Found multiple close matches for the contribution"
     if artefact_name and artefact_classifier:
         message += f" of the {artefact_classifier} '{artefact_name}'"
-    print(f"{message}.")
-    for i, contribution in enumerate(choices):
-        print(f"{i + 1}: {contribution}")
-    choice_number = input(
-        "Please choose the artefact to use for contribution (enter number): "
-    )
+    message += "."
+    return get_user_choice(choices, message)
+
+
+def _has_valid_contribution(artefact: Artefact) -> bool:
+    contribution = artefact.contribution
+    return contribution and contribution.artefact_name and contribution.classifier
+
+
+def get_user_choice(choices: List[str], message: str) -> Optional[str]:
+    """
+    Generic function to present user with a list of choices and return their selection.
+
+    Args:
+        choices: A list of strings representing the choices to display.
+        message: A message to display before listing the choices.
+
+    Returns:
+        The chosen item from the list or None if the input was invalid.
+    """
+    print(message)
+    for i, choice in enumerate(choices):
+        print(f"{i + 1}: {choice}")
+
+    choice_number = input("Please enter your choice (number): ")
+
     try:
         choice_index = int(choice_number) - 1
         if choice_index < 0 or choice_index >= len(choices):
-            print("Invalid choice. Aborting contribution choice.")
+            print("Invalid choice. Aborting operation.")
             return None
-        choice = choices[choice_index]
+        return choices[choice_index]
     except ValueError:
-        print("Invalid input. Aborting contribution choice.")
+        print("Invalid input. Aborting operation.")
         return None
-    return choice
 
 
-def _has_valid_contribution(artefact: Artefact) -> bool:
-    contribution = artefact.contribution
-    return contribution and contribution.artefact_name and contribution.classifier
+def ask_for_rule_choice(matches: List[str]) -> Optional[str]:
+    """Asks the user for a choice between multiple rule matches"""
+    message = "Multiple rule matches found:"
+    return get_user_choice(matches, message)
 
 
 def _update_rule(
@@ -249,6 +265,9 @@ def _update_rule(
         return
     if not closest_rule_match:
         return
+    if len(closest_rule_match) > 1:
+        artefact.contribution.rule = ask_for_rule_choice(closest_rule_match)
+        return
     artefact.contribution.rule = closest_rule_match[0]
 
 

{ara_cli-0.1.9.94 → ara_cli-0.1.9.95}/ara_cli/artefact_creator.py

@@ -106,7 +106,7 @@ class ArtefactCreator:
         if not self.handle_existing_files(file_exists):
             return
 
-        artefact = template_artefact_of_type(classifier, filename, False)
+        artefact = template_artefact_of_type(classifier, filename, True)
 
         if parent_classifier and parent_name:
             artefact.set_contribution(
@@ -114,6 +114,8 @@ class ArtefactCreator:
                 classifier=parent_classifier,
                 rule=rule
             )
+        else:
+            artefact.set_contribution(None, None, None)
 
         artefact_content = artefact.serialize()
         rmtree(dir_path, ignore_errors=True)

{ara_cli-0.1.9.94 → ara_cli-0.1.9.95}/ara_cli/chat.py

@@ -2,6 +2,21 @@ import os
 import argparse
 import cmd2
 from ara_cli.prompt_handler import send_prompt
+from ara_cli.file_loaders.markdown_reader import MarkdownReader
+
+from ara_cli.file_loaders.document_file_loader import DocumentFileLoader
+from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+from ara_cli.file_loaders.text_file_loader import TextFileLoader
+
+
+extract_parser = argparse.ArgumentParser()
+extract_parser.add_argument('-f', '--force', action='store_true', help='Force extraction')
+extract_parser.add_argument('-w','--write', action='store_true', help='Overwrite existing files without using LLM for merging.')
+
+load_parser = argparse.ArgumentParser()
+load_parser.add_argument('file_name', nargs='?', default='', help='File to load')
+load_parser.add_argument('--load-images', action='store_true', help='Extract and describe images from documents')
+
 
 from ara_cli.file_loaders.document_file_loader import DocumentFileLoader
 from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
@@ -822,45 +837,73 @@ Start chatting (type 'HELP'/'h' for available commands, 'QUIT'/'q' to exit chat
         )
         command.execute()
 
+    def _find_givens_files(self, file_name: str) -> list[str]:
+        """
+        Finds the givens files to be processed.
+        - If file_name is provided, it resolves that path.
+        - Otherwise, it looks for default givens files.
+        - If no defaults are found, it prompts the user.
+        Returns a list of absolute file paths or an empty list if none are found.
+        """
+        base_directory = os.path.dirname(self.chat_name)
+
+        def resolve_path(name):
+            """Inner helper to resolve a path relative to chat, then absolute."""
+            relative_path = os.path.join(base_directory, name)
+            if os.path.exists(relative_path):
+                return relative_path
+            if os.path.exists(name):
+                return name
+            return None
+
+        if file_name:
+            path = resolve_path(file_name)
+            if path:
+                return [path]
+            relative_path_for_error = os.path.join(base_directory, file_name)
+            self.perror(f"No givens file found at {relative_path_for_error} or {file_name}")
+            return []
+
+        # If no file_name, check for defaults
+        default_files_to_check = [
+            os.path.join(base_directory, "prompt.data", "config.prompt_givens.md"),
+            os.path.join(base_directory, "prompt.data", "config.prompt_global_givens.md")
+        ]
+        existing_defaults = [f for f in default_files_to_check if os.path.exists(f)]
+        if existing_defaults:
+            return existing_defaults
+
+        # No defaults found, prompt user
+        user_input = input("Please specify a givens file: ")
+        if not user_input:
+            self.poutput("Aborting.")
+            return []
+        
+        path = resolve_path(user_input)
+        if path:
+            return [path]
+        self.perror(f"No givens file found at {user_input}. Aborting.")
+        return []
+
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_LOAD_GIVENS(self, file_name):
-        """Load all files listed in a ./prompt.data/config.prompt_givens.md"""
-        from ara_cli.directory_navigator import DirectoryNavigator
+        """Load all files listed in a ./prompt.data/config.prompt_givens.md and ./prompt.data/config.prompt_global_givens.md"""
         from ara_cli.prompt_handler import load_givens
 
-        base_directory = os.path.dirname(self.chat_name)
-
-        if file_name == "":
-            file_name = f"{base_directory}/prompt.data/config.prompt_givens.md"
-
-        # Check the relative path first
-        relative_givens_path = os.path.join(base_directory, file_name)
-        if os.path.exists(relative_givens_path):
-            givens_path = relative_givens_path
-        elif os.path.exists(file_name):  # Check the absolute path
-            givens_path = file_name
-        else:
-            print(f"No givens file found at {relative_givens_path} or {file_name}")
-            user_input = input("Please specify a givens file: ")
-            if os.path.exists(os.path.join(base_directory, user_input)):
-                givens_path = os.path.join(base_directory, user_input)
-            elif os.path.exists(user_input):
-                givens_path = user_input
-            else:
-                print(f"No givens file found at {user_input}. Aborting.")
-                return
+        givens_files_to_process = self._find_givens_files(file_name)
+        if not givens_files_to_process:
+            self.poutput("No givens files to load.")
+            return
 
-        cwd = os.getcwd()
-        navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
-        os.chdir('..')
-        content, image_data = load_givens(givens_path)
-        os.chdir(cwd)
+        for givens_path in givens_files_to_process:
+            # The givens_path is absolute, and load_givens reconstructs absolute paths
+            # from the markdown file. No directory change is needed.
+            content, _ = load_givens(givens_path)
 
-        with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
-            chat_file.write(content)
+            with open(self.chat_name, 'a', encoding='utf-8') as chat_file:
+                chat_file.write(content)
 
-        print(f"Loaded files listed and marked in {givens_path}")
+            self.poutput(f"Loaded files listed and marked in {givens_path}")
 
     @cmd2.with_category(CATEGORY_CHAT_CONTROL)
     def do_SEND(self, _):

ara_cli-0.1.9.95/ara_cli/file_loaders/document_readers.py

@@ -0,0 +1,233 @@
+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