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

ara_cli/completers.py

@@ -4,18 +4,17 @@ from pathlib import Path
 import typer
 
 from ara_cli.classifier import Classifier
-from ara_cli.template_manager import SpecificationBreakdownAspects
+from ara_cli.constants import VALID_ASPECTS
 
 
 def complete_classifier(incomplete: str) -> List[str]:
     """Complete classifier names."""
-    classifiers = Classifier.ordered_classifiers()
-    return [c for c in classifiers if c.startswith(incomplete)]
+    return [c for c in Classifier.ordered_classifiers() if c.startswith(incomplete)]
 
 
 def complete_aspect(incomplete: str) -> List[str]:
     """Complete aspect names."""
-    aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+    aspects = VALID_ASPECTS
     return [a for a in aspects if a.startswith(incomplete)]
 
 
@@ -31,23 +30,31 @@ def complete_template_type(incomplete: str) -> List[str]:
     return [t for t in template_types if t.startswith(incomplete)]
 
 
-def complete_artefact_name(classifier: str) -> List[str]:
+def complete_artefact_name(classifier: str, incomplete: 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 = []
+        suffix = f".{classifier}"
+
+        # We only care about files that match the incomplete prefix AND the suffix
+        # Since os.listdir gives filenames, we can check startswith(incomplete)
+        # but we must be careful because the file starts with the artefact name, not necessarily the incomplete part + suffix directly unless full match.
+        # Actually, incomplete corresponds to the artefact name part.
+        # So file must start with incomplete AND end with suffix.
+
         for file in os.listdir(classifier_dir):
-            if file.endswith(f'.{classifier}'):
+            if file.startswith(incomplete) and file.endswith(suffix):
                 # Remove the extension to get the artefact name
-                name = file[:-len(f'.{classifier}')]
+                name = file[: -len(suffix)]
                 artefacts.append(name)
-        
+
         return sorted(artefacts)
     except Exception:
         return []
@@ -55,9 +62,10 @@ def complete_artefact_name(classifier: str) -> List[str]:
 
 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 complete_artefact_name(classifier, incomplete)
+
     return completer
 
 
@@ -66,79 +74,131 @@ def complete_chat_files(incomplete: str) -> List[str]:
     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)
-        
+
+        # Optimize by using glob with the incomplete prefix
+        # Note: glob pattern needs to be careful with special chars, but for autocompletion usually fine.
+        pattern = f"{incomplete}*.md" if incomplete else "*.md"
+
+        for file in current_dir.glob(pattern):
+            chat_files.append(file.stem)
+
         return sorted(chat_files)
     except Exception:
         return []
 
 
+def complete_prompt_step(incomplete: str) -> List[str]:
+    """Complete prompt step/subcommand names."""
+    steps = [
+        "init",
+        "load",
+        "send",
+        "load-and-send",
+        "extract",
+        "update",
+        "chat",
+        "init-rag",
+    ]
+    return [s for s in steps if s.startswith(incomplete)]
+
+
 # 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'):
+            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 complete_artefact_name(classifier, 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'):
+            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 complete_artefact_name(parent_classifier, 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
+
+    @staticmethod
+    def create_prompt_step_completer():
+        """Create a completer for prompt step/subcommand names."""
+
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            return complete_prompt_step(incomplete)
+
+        return completer
+
+    @staticmethod
+    def create_convert_source_artefact_name_completer():
+        """Create a completer for convert command source artefact names based on old_classifier context."""
+
+        def completer(ctx: typer.Context, incomplete: str) -> List[str]:
+            # Try to get old_classifier from context
+            if hasattr(ctx, "params") and "old_classifier" in ctx.params:
+                old_classifier = ctx.params["old_classifier"]
+                if hasattr(old_classifier, "value"):
+                    old_classifier = old_classifier.value
+                return complete_artefact_name(old_classifier, incomplete)
+            return []
+
         return completer

ara_cli/constants.py

@@ -0,0 +1,2 @@
+
+VALID_ASPECTS = ["technology", "concept", "persona", "customer", "step"]

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

@@ -5,8 +5,9 @@ from enum import Enum
 from functools import wraps
 
 
-RED = '\033[91m'
-RESET = '\033[0m'
+RED = "\033[91m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
 
 
 class ErrorLevel(Enum):
@@ -69,7 +70,6 @@ class ErrorHandler:
 
         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):
@@ -77,33 +77,44 @@ class ErrorHandler:
         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}]"
 
+        # Choose color based on error level
+        if error.level in (ErrorLevel.INFO, ErrorLevel.WARNING):
+            color = YELLOW
+        else:
+            color = RED
+
         if context:
-            print(f"{RED}{error_prefix} {context}: {error.message}{RESET}", file=sys.stderr)
+            print(
+                f"{color}{error_prefix} {context}: {error.message}{RESET}",
+                file=sys.stderr,
+            )
         else:
-            print(f"{RED}{error_prefix} {error.message}{RESET}", file=sys.stderr)
+            print(f"{color}{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:
+    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)
+            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:
@@ -112,7 +123,11 @@ class ErrorHandler:
             raise AraValidationError(message)
 
 
-def handle_errors(_func=None, context: Optional[str] = None, error_handler: Optional[ErrorHandler] = None):
+def handle_errors(
+    _func=None,
+    context: Optional[str] = None,
+    error_handler: Optional[ErrorHandler] = None,
+):
     """Decorator to handle errors in action functions"""
 
     def decorator(func):

ara_cli/file_loaders/document_reader.py

@@ -61,185 +61,7 @@ class DocumentReader(ABC):
         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

ara_cli/file_loaders/factories/document_reader_factory.py

@@ -0,0 +1,32 @@
+import os
+from typing import Optional
+from ara_cli.file_loaders.document_reader import DocumentReader
+from ara_cli.file_loaders.readers.docx_reader import DocxReader
+from ara_cli.file_loaders.readers.pdf_reader import PdfReader
+from ara_cli.file_loaders.readers.odt_reader import OdtReader
+from ara_cli.file_loaders.readers.excel_reader import ExcelReader
+from ara_cli.file_loaders.readers.pptx_reader import PptxReader
+
+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,
+            '.xlsx': ExcelReader,
+            '.xls': ExcelReader,
+            '.pptx': PptxReader
+        }
+
+        reader_class = readers.get(ext)
+        if reader_class:
+            return reader_class(file_path)
+
+        return None

ara_cli/file_loaders/factories/file_loader_factory.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from ara_cli import BINARY_TYPE_MAPPING, DOCUMENT_TYPE_EXTENSIONS
+from ara_cli.file_loaders.file_loader import FileLoader
+
+class FileLoaderFactory:
+    """Factory for creating appropriate file loaders"""
+
+    @staticmethod
+    def create_loader(file_name: str, chat_instance) -> Optional[FileLoader]:
+        """Create appropriate loader based on file type"""
+        from ara_cli.file_loaders.loaders.binary_file_loader import BinaryFileLoader
+        from ara_cli.file_loaders.loaders.text_file_loader import TextFileLoader
+        from ara_cli.file_loaders.loaders.document_file_loader import DocumentFileLoader
+
+        file_name_lower = file_name.lower()
+
+        # Check if it's a binary file
+        for extension, mime_type in BINARY_TYPE_MAPPING.items():
+            if file_name_lower.endswith(extension):
+                return BinaryFileLoader(chat_instance)
+
+        # Check if it's a document
+        if any(file_name_lower.endswith(ext) for ext in DOCUMENT_TYPE_EXTENSIONS):
+            return DocumentFileLoader(chat_instance)
+
+        # Default to text file loader
+        return TextFileLoader(chat_instance)

ara_cli/file_loaders/file_loader.py

@@ -18,33 +18,4 @@ class FileLoader(ABC):
         self.chat.add_prompt_tag_if_needed(self.chat.chat_name)
 
 
-class FileLoaderFactory:
-    """Factory for creating appropriate file loaders"""
-    BINARY_TYPE_MAPPING = {
-        ".png": "image/png",
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-    }
-
-    DOCUMENT_TYPE_EXTENSIONS = [".docx", ".doc", ".odt", ".pdf"]
-
-    @staticmethod
-    def create_loader(file_name: str, chat_instance) -> Optional[FileLoader]:
-        """Create appropriate loader based on file type"""
-        from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
-        from ara_cli.file_loaders.text_file_loader import TextFileLoader
-        from ara_cli.file_loaders.document_file_loader import DocumentFileLoader
-
-        file_name_lower = file_name.lower()
-
-        # Check if it's a binary file
-        for extension, mime_type in FileLoaderFactory.BINARY_TYPE_MAPPING.items():
-            if file_name_lower.endswith(extension):
-                return BinaryFileLoader(chat_instance)
-
-        # Check if it's a document
-        if any(file_name_lower.endswith(ext) for ext in FileLoaderFactory.DOCUMENT_TYPE_EXTENSIONS):
-            return DocumentFileLoader(chat_instance)
-
-        # Default to text file loader
-        return TextFileLoader(chat_instance)
+

ara_cli/file_loaders/{document_file_loader.py → loaders/document_file_loader.py}

@@ -1,4 +1,4 @@
-from ara_cli.file_loaders.document_reader import DocumentReaderFactory
+from ara_cli.file_loaders.factories.document_reader_factory import DocumentReaderFactory
 from ara_cli.file_loaders.file_loader import FileLoader