ara-cli 0.1.9.77__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

ara_cli/completers.py

@@ -0,0 +1,144 @@
+import os
+from typing import List, Optional
+from pathlib import Path
+import typer
+
+from ara_cli.classifier import Classifier
+from ara_cli.template_manager import SpecificationBreakdownAspects
+
+
+def complete_classifier(incomplete: str) -> List[str]:
+    """Complete classifier names."""
+    classifiers = Classifier.ordered_classifiers()
+    return [c for c in classifiers if c.startswith(incomplete)]
+
+
+def complete_aspect(incomplete: str) -> List[str]:
+    """Complete aspect names."""
+    aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+    return [a for a in aspects if a.startswith(incomplete)]
+
+
+def complete_status(incomplete: str) -> List[str]:
+    """Complete task status values."""
+    statuses = ["to-do", "in-progress", "review", "done", "closed"]
+    return [s for s in statuses if s.startswith(incomplete)]
+
+
+def complete_template_type(incomplete: str) -> List[str]:
+    """Complete template type values."""
+    template_types = ["rules", "intention", "commands", "blueprint"]
+    return [t for t in template_types if t.startswith(incomplete)]
+
+
+def complete_artefact_name(classifier: str) -> List[str]:
+    """Complete artefact names for a given classifier."""
+    try:
+        # Get the directory for the classifier
+        classifier_dir = f"ara/{Classifier.get_sub_directory(classifier)}"
+        
+        if not os.path.exists(classifier_dir):
+            return []
+        
+        # Find all files with the classifier extension
+        artefacts = []
+        for file in os.listdir(classifier_dir):
+            if file.endswith(f'.{classifier}'):
+                # Remove the extension to get the artefact name
+                name = file[:-len(f'.{classifier}')]
+                artefacts.append(name)
+        
+        return sorted(artefacts)
+    except Exception:
+        return []
+
+
+def complete_artefact_name_for_classifier(classifier: str):
+    """Create a completer function for artefact names of a specific classifier."""
+    def completer(incomplete: str) -> List[str]:
+        artefacts = complete_artefact_name(classifier)
+        return [a for a in artefacts if a.startswith(incomplete)]
+    return completer
+
+
+def complete_chat_files(incomplete: str) -> List[str]:
+    """Complete chat file names (without .md extension)."""
+    try:
+        chat_files = []
+        current_dir = Path.cwd()
+        
+        # Look for .md files in current directory
+        for file in current_dir.glob("*.md"):
+            name = file.stem
+            if name.startswith(incomplete):
+                chat_files.append(name)
+        
+        return sorted(chat_files)
+    except Exception:
+        return []
+
+
+# Dynamic completers that need context
+class DynamicCompleters:
+    @staticmethod
+    def create_classifier_completer():
+        """Create a completer for classifiers."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_classifier(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_aspect_completer():
+        """Create a completer for aspects."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_aspect(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_status_completer():
+        """Create a completer for status values."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_status(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_template_type_completer():
+        """Create a completer for template types."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_template_type(incomplete)
+        return completer
+    
+    @staticmethod
+    def create_artefact_name_completer():
+        """Create a completer for artefact names based on classifier context."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get classifier from context
+            if hasattr(ctx, 'params') and 'classifier' in ctx.params:
+                classifier = ctx.params['classifier']
+                if hasattr(classifier, 'value'):
+                    classifier = classifier.value
+                artefacts = complete_artefact_name(classifier)
+                return [a for a in artefacts if a.startswith(incomplete)]
+            return []
+        return completer
+    
+    @staticmethod
+    def create_parent_name_completer():
+        """Create a completer for parent artefact names based on parent classifier context."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get parent_classifier from context
+            if hasattr(ctx, 'params') and 'parent_classifier' in ctx.params:
+                parent_classifier = ctx.params['parent_classifier']
+                if hasattr(parent_classifier, 'value'):
+                    parent_classifier = parent_classifier.value
+                artefacts = complete_artefact_name(parent_classifier)
+                return [a for a in artefacts if a.startswith(incomplete)]
+            return []
+        return completer
+    
+    @staticmethod
+    def create_chat_file_completer():
+        """Create a completer for chat files."""
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_chat_files(incomplete)
+        return completer

ara_cli/directory_navigator.py

@@ -1,4 +1,5 @@
 import os
+import sys
 from os.path import join, exists, isdir, dirname, basename
 # from ara_cli.directory_searcher import DirectorySearcher
 
@@ -23,7 +24,8 @@ class DirectoryNavigator:
             return original_directory
 
         current_directory = original_directory
-        while current_directory != dirname(current_directory):  # Ensure loop breaks at root
+        # Ensure loop breaks at root
+        while current_directory != dirname(current_directory):
             potential_path = join(current_directory, self.target_directory)
             if self.exists(potential_path):
                 os.chdir(potential_path)
@@ -31,7 +33,8 @@ class DirectoryNavigator:
             current_directory = dirname(current_directory)
 
         # If the loop completes, the target directory was not found
-        user_input = input(f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
+        user_input = input(
+            f"Unable to locate the '{self.target_directory}' directory. Do you want to create an 'ara' folder in the working directory? (y/N): ").strip().lower()
 
         if user_input == '' or user_input == 'y':
             ara_folder_path = join(original_directory, 'ara')
@@ -40,7 +43,8 @@ class DirectoryNavigator:
             os.chdir(ara_folder_path)
             return original_directory
         else:
-            print(f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
+            print(
+                f"Unable to locate the '{self.target_directory}' directory and user declined to create 'ara' folder.")
             sys.exit(0)
 
     def navigate_to_relative(self, relative_path):
@@ -56,7 +60,36 @@ class DirectoryNavigator:
         if self.exists(path):
             os.chdir(path)
         else:
-            raise Exception(f"Unable to navigate to '{relative_path}' relative to the target directory.")
+            raise Exception(
+                f"Unable to navigate to '{relative_path}' relative to the target directory.")
+
+    @staticmethod
+    def find_ara_directory_root():
+        """Find the root ara directory by traversing up the directory tree."""
+        current_dir = os.getcwd()
+
+        # Check if we're already inside an ara directory structure
+        path_parts = current_dir.split(os.sep)
+
+        # Look for 'ara' in the path parts
+        if 'ara' in path_parts:
+            ara_index = path_parts.index('ara')
+            # Reconstruct path up to and including 'ara'
+            ara_root_parts = path_parts[:ara_index + 1]
+            potential_ara_root = os.sep.join(ara_root_parts)
+            if os.path.exists(potential_ara_root) and os.path.isdir(potential_ara_root):
+                return potential_ara_root
+
+        # If not inside ara directory, check current directory and parents
+        check_dir = current_dir
+        # Stop at filesystem root
+        while check_dir != os.path.dirname(check_dir):
+            ara_path = os.path.join(check_dir, 'ara')
+            if os.path.exists(ara_path) and os.path.isdir(ara_path):
+                return ara_path
+            check_dir = os.path.dirname(check_dir)
+
+        return None
 
     # debug version
     # def get_ara_directory(self):

ara_cli/error_handler.py

@@ -0,0 +1,134 @@
+import sys
+import traceback
+from typing import Optional
+from enum import Enum
+from functools import wraps
+
+
+RED = '\033[91m'
+RESET = '\033[0m'
+
+
+class ErrorLevel(Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class AraError(Exception):
+    """Base exception class for ARA CLI errors"""
+
+    def __init__(
+        self, message: str, error_code: int = 1, level: ErrorLevel = ErrorLevel.ERROR
+    ):
+        self.message = message
+        self.error_code = error_code
+        self.level = level
+        super().__init__(self.message)
+
+
+class AraValidationError(AraError):
+    """Raised when validation fails"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=2, level=ErrorLevel.ERROR)
+
+
+class AraConfigurationError(AraError):
+    """Raised when configuration is invalid"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=4, level=ErrorLevel.ERROR)
+
+
+class ErrorHandler:
+    """Centralized error handler for ARA CLI"""
+
+    def __init__(self, debug_mode: bool = False):
+        self.debug_mode = debug_mode
+
+    def handle_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Handle any error with standardized output"""
+        if isinstance(error, AraError):
+            self._handle_ara_error(error, context)
+        else:
+            self._handle_generic_error(error, context)
+
+    def _handle_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Handle ARA-specific errors"""
+        self._report_ara_error(error, context)
+
+        sys.exit(error.error_code)
+
+    def _handle_generic_error(
+        self, error: Exception, context: Optional[str] = None
+    ) -> None:
+        """Handle generic Python errors"""
+        self._report_generic_error(error, context)
+
+        sys.exit(1)
+
+
+    def report_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report error with standardized formatting but don't exit"""
+        if isinstance(error, AraError):
+            self._report_ara_error(error, context)
+        else:
+            self._report_generic_error(error, context)
+
+
+    def _report_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Report ARA-specific errors without exiting"""
+        error_prefix = f"[{error.level.value}]"
+
+        if context:
+            print(f"{RED}{error_prefix} {context}: {error.message}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}{error_prefix} {error.message}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def _report_generic_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report generic Python errors without exiting"""
+        error_type = type(error).__name__
+
+        if context:
+            print(f"{RED}[ERROR] {context}: {error_type}: {str(error)}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}[ERROR] {error_type}: {str(error)}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def validate_and_exit(
+        self, condition: bool, message: str, error_code: int = 1
+    ) -> None:
+        """Validate condition and exit with error if false"""
+        if not condition:
+            raise AraValidationError(message)
+
+
+def handle_errors(_func=None, context: Optional[str] = None, error_handler: Optional[ErrorHandler] = None):
+    """Decorator to handle errors in action functions"""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            nonlocal error_handler
+            if error_handler is None:
+                error_handler = ErrorHandler()
+
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                error_handler.handle_error(e, context or func.__name__)
+
+        return wrapper
+
+    if callable(_func):
+        return decorator(_func)
+    return decorator

ara_cli/file_classifier.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.artefact_fuzzy_search import find_closest_name_matches
@@ -33,8 +34,8 @@ class FileClassifier:
                     if byte > 127:
                         return True
         except Exception as e:
-            # Handle unexpected errors while reading the file in binary mode
-            print(f"Error while checking if file is binary: {e}")
+            error_handler.report_error(e, "checking if file is binary")
+            # print(f"Error while checking if file is binary: {e}")
         return False
 
     def read_file_with_fallback(self, file_path):

ara_cli/file_loaders/binary_file_loader.py

@@ -0,0 +1,33 @@
+import base64
+import os
+from ara_cli.file_loaders.file_loader import FileLoader
+
+
+class BinaryFileLoader(FileLoader):
+    """Loads binary files (images)"""
+
+    def load(
+        self,
+        file_path: str,
+        mime_type: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False
+    ) -> bool:
+        """Load binary file as base64"""
+
+        with open(file_path, 'rb') as file:
+            file_content = file.read()
+
+        base64_image = base64.b64encode(file_content).decode("utf-8")
+
+        if block_delimiter:
+            file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"
+
+        write_content = f"{prefix}![{os.path.basename(file_path)}](data:{mime_type};base64,{base64_image}){suffix}\n"
+
+        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
+            chat_file.write(write_content)
+
+        return True

ara_cli/file_loaders/document_file_loader.py

@@ -0,0 +1,34 @@
+from ara_cli.file_loaders.document_reader import DocumentReaderFactory
+from ara_cli.file_loaders.file_loader import FileLoader
+
+
+class DocumentFileLoader(FileLoader):
+    """Loads document files (PDF, DOCX, ODT)"""
+
+    def load(
+        self,
+        file_path: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "```",
+        extract_images: bool = False
+    ) -> bool:
+        """Load document file with optional image extraction"""
+
+        reader = DocumentReaderFactory.create_reader(file_path)
+
+        if not reader:
+            print("Unsupported document type.")
+            return False
+
+        text_content = reader.read(extract_images=extract_images)
+
+        if block_delimiter:
+            text_content = f"{block_delimiter}\n{text_content}\n{block_delimiter}"
+
+        write_content = f"{prefix}{text_content}{suffix}\n"
+
+        with open(self.chat.chat_name, 'a', encoding='utf-8') as chat_file:
+            chat_file.write(write_content)
+
+        return True

ara_cli/file_loaders/document_reader.py

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