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

ara_cli/classifier.py

@@ -72,3 +72,37 @@ class Classifier:
     @lru_cache(maxsize=None)
     def artefact_titles():
         return Classifier.artefact_title.values()
+
+    # Leaf-node classifiers that cannot have children
+    _leaf_classifiers = {"task", "issue"}
+
+    # Contribution hierarchy: child -> valid parent classifiers
+    contribution_hierarchy = {
+        "businessgoal": ["vision"],
+        "capability": ["vision", "businessgoal"],
+        "keyfeature": ["vision", "businessgoal", "capability"],
+        "epic": ["vision", "businessgoal", "capability", "keyfeature"],
+        "userstory": ["vision", "businessgoal", "capability", "keyfeature", "epic"],
+        "example": ["vision", "businessgoal", "capability", "keyfeature", "epic", "userstory"],
+        "feature": ["vision", "businessgoal", "capability", "keyfeature", "epic", "userstory"],
+        "task": ["vision", "businessgoal", "capability", "keyfeature", "epic", "userstory", "feature"],
+        "issue": ["vision", "businessgoal", "capability", "keyfeature", "epic", "userstory", "feature"],
+    }
+
+    @staticmethod
+    @lru_cache(maxsize=None)
+    def can_have_children(classifier: str) -> bool:
+        """
+        Check if a classifier can have children artefacts.
+        Task and Issue are leaf-node classifiers and cannot have children.
+        """
+        return classifier not in Classifier._leaf_classifiers
+
+    @staticmethod
+    @lru_cache(maxsize=None)
+    def get_valid_parent_classifiers(child_classifier: str) -> list:
+        """
+        Get list of valid parent classifiers for a given child classifier.
+        Returns empty list if classifier has no valid parents (e.g., vision).
+        """
+        return Classifier.contribution_hierarchy.get(child_classifier, [])

ara_cli/commands/load_command.py

@@ -1,6 +1,7 @@
 from ara_cli.commands.command import Command
-from ara_cli.file_loaders.file_loader import FileLoaderFactory
-from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+from ara_cli.file_loaders.factories.file_loader_factory import FileLoaderFactory
+from ara_cli.file_loaders.loaders.binary_file_loader import BinaryFileLoader
+from ara_cli import BINARY_TYPE_MAPPING
 
 
 class LoadCommand(Command):
@@ -29,7 +30,7 @@ class LoadCommand(Command):
             # Determine mime type for binary files
             file_name_lower = self.file_path.lower()
             mime_type = None
-            for extension, mt in FileLoaderFactory.BINARY_TYPE_MAPPING.items():
+            for extension, mt in BINARY_TYPE_MAPPING.items():
                 if file_name_lower.endswith(extension):
                     mime_type = mt
                     break

ara_cli/commands/load_image_command.py

@@ -1,5 +1,5 @@
 from ara_cli.commands.command import Command
-from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
+from ara_cli.file_loaders.loaders.binary_file_loader import BinaryFileLoader
 
 
 class LoadImageCommand(Command):

ara_cli/commands/read_command.py

@@ -3,9 +3,9 @@ from ara_cli.artefact_reader import ArtefactReader
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.list_filter import ListFilter, filter_list
 from ara_cli.artefact_models.artefact_data_retrieval import (
-    artefact_content_retrieval, 
-    artefact_path_retrieval, 
-    artefact_tags_retrieval
+    artefact_content_retrieval,
+    artefact_path_retrieval,
+    artefact_tags_retrieval,
 )
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
 import os
@@ -18,7 +18,7 @@ class ReadCommand(Command):
         artefact_name: str,
         read_mode: str = "default",
         list_filter: ListFilter = None,
-        output=None
+        output=None,
     ):
         self.classifier = classifier
         self.artefact_name = artefact_name
@@ -29,7 +29,8 @@ class ReadCommand(Command):
     def execute(self) -> bool:
         """Execute the read command and return success status."""
         file_classifier = FileClassifier(os)
-        classified_artefacts = ArtefactReader.read_artefacts()
+        reader = ArtefactReader()
+        classified_artefacts = reader.read_artefacts()
 
         if not self.classifier or not self.artefact_name:
             self._filter_and_print(classified_artefacts, file_classifier)
@@ -39,15 +40,12 @@ class ReadCommand(Command):
         all_artefact_names = [a.title for a in artefacts]
 
         if self.artefact_name not in all_artefact_names:
-            suggest_close_name_matches(
-                self.artefact_name,
-                all_artefact_names
-            )
+            suggest_close_name_matches(self.artefact_name, all_artefact_names)
             return False
 
-        target_artefact = next(filter(
-            lambda x: x.title == self.artefact_name, artefacts
-        ))
+        target_artefact = next(
+            filter(lambda x: x.title == self.artefact_name, artefacts)
+        )
 
         artefacts_by_classifier = {self.classifier: []}
 
@@ -55,16 +53,14 @@ class ReadCommand(Command):
             match self.read_mode:
                 case "branch":
                     self._handle_branch_mode(
-                        classified_artefacts, artefacts_by_classifier
+                        classified_artefacts, artefacts_by_classifier, reader
                     )
                 case "children":
                     artefacts_by_classifier = self._handle_children_mode(
-                        classified_artefacts
+                        classified_artefacts, reader
                     )
                 case _:
-                    self._handle_default_mode(
-                        target_artefact, artefacts_by_classifier
-                    )
+                    self._handle_default_mode(target_artefact, artefacts_by_classifier)
 
             # Apply filtering and print results
             self._filter_and_print(artefacts_by_classifier, file_classifier)
@@ -78,21 +74,23 @@ class ReadCommand(Command):
             self.output(f"Error reading artefact: {e}")
             return False
 
-    def _handle_branch_mode(self, classified_artefacts, artefacts_by_classifier):
+    def _handle_branch_mode(
+        self, classified_artefacts, artefacts_by_classifier, reader
+    ):
         """Handle branch read mode."""
-        ArtefactReader.step_through_value_chain(
+        reader.step_through_value_chain(
             artefact_name=self.artefact_name,
             classifier=self.classifier,
             artefacts_by_classifier=artefacts_by_classifier,
-            classified_artefacts=classified_artefacts
+            classified_artefacts=classified_artefacts,
         )
 
-    def _handle_children_mode(self, classified_artefacts):
+    def _handle_children_mode(self, classified_artefacts, reader):
         """Handle children read mode."""
-        return ArtefactReader.find_children(
+        return reader.find_children(
             artefact_name=self.artefact_name,
             classifier=self.classifier,
-            classified_artefacts=classified_artefacts
+            classified_artefacts=classified_artefacts,
         )
 
     def _handle_default_mode(self, target_artefact, artefacts_by_classifier):
@@ -106,12 +104,10 @@ class ReadCommand(Command):
             list_filter=self.list_filter,
             content_retrieval_strategy=artefact_content_retrieval,
             file_path_retrieval=artefact_path_retrieval,
-            tag_retrieval=artefact_tags_retrieval
+            tag_retrieval=artefact_tags_retrieval,
         )
 
     def _filter_and_print(self, artefacts_by_classifier, file_classifier):
         """Apply list filtering and print results"""
         filtered_artefacts = self._apply_filtering(artefacts_by_classifier)
-        file_classifier.print_classified_files(
-            filtered_artefacts, print_content=True
-        )
+        file_classifier.print_classified_files(filtered_artefacts, print_content=True)

ara_cli/completers.py

@@ -87,6 +87,21 @@ def complete_chat_files(incomplete: str) -> List[str]:
         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
@@ -164,6 +179,15 @@ class DynamicCompleters:
 
         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."""

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
 
 

ara_cli/file_loaders/loaders/text_file_loader.py

@@ -0,0 +1,47 @@
+import os
+import re
+import base64
+import tempfile
+from typing import Optional, Tuple
+import requests
+from charset_normalizer import from_path
+from ara_cli.file_loaders.file_loader import FileLoader
+from ara_cli.file_loaders.readers.markdown_reader import MarkdownReader
+
+
+class TextFileLoader(FileLoader):
+    """Loads text files"""
+
+    def load(
+        self,
+        file_path: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False,
+        **kwargs,
+    ) -> bool:
+        """Load text file with optional markdown image extraction"""
+
+        is_md_file = file_path.lower().endswith(".md")
+
+        if is_md_file and extract_images:
+            reader = MarkdownReader(file_path)
+            file_content = reader.read(extract_images=True).replace("\r\n", "\n")
+        else:
+            # Use charset-normalizer to detect encoding
+            encoded_content = from_path(file_path).best()
+            if not encoded_content:
+                print(f"Failed to detect encoding for {file_path}")
+                return False
+            file_content = str(encoded_content).replace("\r\n", "\n")
+
+        if block_delimiter:
+            file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"
+
+        write_content = f"{prefix}{file_content}{suffix}\n"
+
+        with open(self.chat.chat_name, "a", encoding="utf-8") as chat_file:
+            chat_file.write(write_content)
+
+        return True