ara-cli 0.1.9.69__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,6 +1,7 @@
+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_match
+from ara_cli.artefact_fuzzy_search import find_closest_name_matches
 from functools import lru_cache
 from typing import Optional
 import textwrap
@@ -17,7 +18,7 @@ class FileClassifier:
             info["title"] for info in classified_artefacts.get(classifier, [])]
         if name in all_artefact_names:
             return name
-        return find_closest_name_match(name, all_artefact_names)
+        return find_closest_name_matches(name, all_artefact_names)
 
     @lru_cache(maxsize=None)
     def read_file_content(self, file_path):
@@ -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):
@@ -68,7 +69,7 @@ class FileClassifier:
         files_by_classifier = {classifier: [] for classifier in Classifier.ordered_classifiers()}
 
         for root, _, files in self.file_system.walk("."):
-            if root.endswith(".data"):
+            if root.endswith(".data") or root.endswith("templates"):
                 continue
             for file in files:
                 file_path = self.file_system.path.join(root, file)

ara_cli/file_lister.py

@@ -28,7 +28,7 @@ def generate_markdown_listing(directories, file_types_to_be_listed, output_file_
                 if any(fnmatch.fnmatch(file, pattern) for pattern in file_types_to_be_listed):
                     markdown_lines.append(f"{indent} - [] {file}")
 
-    with open(output_file_path, "w") as md_file:
+    with open(output_file_path, "w", encoding="utf-8") as md_file:
         md_file.write('\n'.join(markdown_lines))
 
 

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