ara-cli 0.1.9.84__py3-none-any.whl → 0.1.9.85__py3-none-any.whl

ara_cli/ara_command_action.py

@@ -616,7 +616,7 @@ def extract_action(args):
 
     filename = args.filename
     skip_queries = args.skip_queries
-    print(file_name)
+    print(filename)
     command = ExtractCommand(
         file_name=filename,
         skip_queries=skip_queries,

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

ara_cli/file_loaders/file_loader.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class FileLoader(ABC):
+    """Abstract base class for file loaders"""
+
+    def __init__(self, chat_instance):
+        self.chat = chat_instance
+
+    @abstractmethod
+    def load(self, file_path: str, **kwargs) -> bool:
+        """Load file with specific implementation"""
+        pass
+
+    def add_prompt_tag_if_needed(self):
+        """Add prompt tag to chat if needed"""
+        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/text_file_loader.py

@@ -0,0 +1,189 @@
+import os
+import re
+import base64
+import tempfile
+from typing import Optional, Tuple
+import requests
+from ara_cli.prompt_handler import describe_image
+from ara_cli.file_loaders.file_loader import FileLoader
+
+
+class TextFileLoader(FileLoader):
+    """Loads text files"""
+
+    def load(
+        self,
+        file_path: str,
+        prefix: str = "",
+        suffix: str = "",
+        block_delimiter: str = "",
+        extract_images: bool = False
+    ) -> 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)
+        else:
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as file:
+                file_content = file.read()
+
+        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
+
+
+class MarkdownReader:
+    """Handles markdown file reading with optional image extraction"""
+
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.base_dir = os.path.dirname(file_path)
+        self.image_processor = ImageProcessor()
+
+    def read(self, extract_images: bool = False) -> str:
+        """Read markdown file and optionally extract/describe images"""
+        with open(self.file_path, 'r', encoding='utf-8') as file:
+            content = file.read()
+
+        if not extract_images:
+            return content
+
+        return self._process_images(content)
+
+    def _process_images(self, content: str) -> str:
+        """Process all images in markdown content"""
+        # Pattern to match markdown images: ![alt text](url or path)
+        image_pattern = re.compile(r'!\[([^\]]*)\]\(([^\)]+)\)')
+        base64_pattern = re.compile(r'data:image/([^;]+);base64,([^)]+)')
+
+        # Process each image reference
+        for match in image_pattern.finditer(content):
+            image_ref = match.group(2)
+            replacement = self._process_single_image(image_ref, base64_pattern)
+
+            if replacement:
+                content = content.replace(match.group(0), replacement, 1)
+
+        return content
+
+    def _process_single_image(self, image_ref: str, base64_pattern: re.Pattern) -> Optional[str]:
+        """Process a single image reference"""
+        try:
+            # Try base64 first
+            result = self.image_processor.process_base64_image(
+                image_ref, base64_pattern)
+            if result:
+                return result[0]
+
+            # Try URL
+            result, error = self.image_processor.process_url_image(image_ref)
+            if result:
+                if error:
+                    print(f"Warning: {error}")
+                return result
+
+            # Try local file
+            result, error = self.image_processor.process_local_image(
+                image_ref, self.base_dir)
+            if error:
+                print(f"Warning: {error}")
+            return result
+
+        except Exception as e:
+            print(f"Warning: Could not process image {image_ref}: {e}")
+            return None
+
+
+class ImageProcessor:
+    """Handles image processing operations"""
+
+    @staticmethod
+    def process_base64_image(
+        image_ref: str,
+        base64_pattern: re.Pattern
+    ) -> Optional[Tuple[str, str]]:
+        """Process base64 encoded image and return description"""
+        base64_match = base64_pattern.match(image_ref)
+        if not base64_match:
+            return None
+
+        image_format = base64_match.group(1)
+        base64_data = base64_match.group(2)
+        image_data = base64.b64decode(base64_data)
+
+        # Create a temporary file to send to LLM
+        with tempfile.NamedTemporaryFile(suffix=f'.{image_format}', delete=False) as tmp_file:
+            tmp_file.write(image_data)
+            tmp_file_path = tmp_file.name
+
+        try:
+            description = describe_image(tmp_file_path)
+            return f"Image: (base64 embedded {image_format} image)\n[{description}]", None
+        finally:
+            os.unlink(tmp_file_path)
+
+    @staticmethod
+    def process_url_image(image_ref: str) -> Tuple[str, Optional[str]]:
+        """Process image from URL and return description"""
+        if not image_ref.startswith(('http://', 'https://')):
+            return "", None
+
+        try:
+            response = requests.get(image_ref, timeout=10)
+            response.raise_for_status()
+
+            # Determine file extension from content-type
+            content_type = response.headers.get('content-type', '')
+            ext = ImageProcessor._get_extension_from_content_type(
+                content_type, image_ref)
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(suffix=ext, delete=False) as tmp_file:
+                tmp_file.write(response.content)
+                tmp_file_path = tmp_file.name
+
+            try:
+                description = describe_image(tmp_file_path)
+                return f"Image: {image_ref}\n[{description}]", None
+            finally:
+                os.unlink(tmp_file_path)
+
+        except Exception as e:
+            error_msg = f"Could not download image: {str(e)}"
+            return f"Image: {image_ref}\n[{error_msg}]", error_msg
+
+    @staticmethod
+    def process_local_image(image_ref: str, base_dir: str) -> Tuple[str, Optional[str]]:
+        """Process local image file and return description"""
+        if os.path.isabs(image_ref):
+            local_image_path = image_ref
+        else:
+            local_image_path = os.path.join(base_dir, image_ref)
+
+        if os.path.exists(local_image_path):
+            description = describe_image(local_image_path)
+            return f"Image: {image_ref}\n[{description}]", None
+        else:
+            error_msg = f"Image file not found"
+            return f"Image: {image_ref}\n[{error_msg}]", f"Local image not found: {local_image_path}"
+
+    @staticmethod
+    def _get_extension_from_content_type(content_type: str, url: str) -> str:
+        """Determine file extension from content type or URL"""
+        if 'image/jpeg' in content_type:
+            return '.jpg'
+        elif 'image/png' in content_type:
+            return '.png'
+        elif 'image/gif' in content_type:
+            return '.gif'
+        else:
+            return os.path.splitext(url)[1] or '.png'

ara_cli/prompt_extractor.py

@@ -1,13 +1,12 @@
-from ara_cli.prompt_handler import send_prompt, get_file_content
-from ara_cli.classifier import Classifier
-from ara_cli.directory_navigator import DirectoryNavigator
-from ara_cli.artefact_models.artefact_mapping import title_prefix_to_artefact_class
 import re
 import json
-import json_repair
 import os
-
+import json_repair
 from markdown_it import MarkdownIt
+from ara_cli.prompt_handler import send_prompt, get_file_content
+from ara_cli.classifier import Classifier
+from ara_cli.directory_navigator import DirectoryNavigator
+from ara_cli.artefact_models.artefact_mapping import title_prefix_to_artefact_class
 
 
 def extract_code_blocks_md(markdown_text):
@@ -21,7 +20,7 @@ def extract_responses(document_path, relative_to_ara_root=False, skip_queries=Fa
     print(f"Debug: Starting extraction from {document_path}")
     block_extraction_counter = 0
 
-    with open(document_path, 'r', encoding='utf-8') as file:
+    with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
         content = file.read()
 
     cwd = os.getcwd()
@@ -114,7 +113,7 @@ def modify_and_save_file(response, file_path):
                 print("Skipping block.")
                 return
 
-        with open(file_path, 'w', encoding='utf-8') as file:
+        with open(file_path, 'w', encoding='utf-8', errors='replace') as file:
             file.write(response_data['content'])
             print(f"File {file_path} updated successfully.")
     except json.JSONDecodeError as ex:

ara_cli/version.py

@@ -1,2 +1,2 @@
 # version.py
-__version__ = "0.1.9.84"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers
+__version__ = "0.1.9.85"   # fith parameter like .0 for local install test purposes only. official numbers should be 4 digit numbers

{ara_cli-0.1.9.84.dist-info → ara_cli-0.1.9.85.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.84
+Version: 0.1.9.85
 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

{ara_cli-0.1.9.84.dist-info → ara_cli-0.1.9.85.dist-info}/RECORD

@@ -1,6 +1,6 @@
 ara_cli/__init__.py,sha256=0zl7IegxTid26EBGLav_fXZ4CCIV3H5TfAoFQiOHjvg,148
 ara_cli/__main__.py,sha256=J5DCDLRZ6UcpYwM1-NkjaLo4PTetcSj2dB4HrrftkUw,2064
-ara_cli/ara_command_action.py,sha256=a6yqYg40QW8UXSq85J33bZqPNQkjhRkLcS2flt0Zacs,22457
+ara_cli/ara_command_action.py,sha256=_LHE2V5hbJxN7ccYiptuPktRfbTnXmQEt_D_FxDBlBY,22456
 ara_cli/ara_command_parser.py,sha256=I-e9W-QwTIMKMzlHycSlCWCyBFQfiFYvGre1XsDbrFI,20573
 ara_cli/ara_config.py,sha256=SgZfQVpqj5JJN4SB0n2IvAH0sKIdS3k1K1Zht2wDywA,8814
 ara_cli/artefact_autofix.py,sha256=WVTiIR-jo4YKmmz4eS3qTFvl45W1YKwAk1XSuz9QX10,20015
@@ -24,14 +24,14 @@ ara_cli/filename_validator.py,sha256=Aw9PL8d5-Ymhp3EY6lDrUBk3cudaNqo1Uw5RzPpI1jA
 ara_cli/list_filter.py,sha256=qKGwwQsrWe7L5FbdxEbBYD1bbbi8c-RMypjXqXvLbgs,5291
 ara_cli/output_suppressor.py,sha256=nwiHaQLwabOjMoJOeUESBnZszGMxrQZfJ3N2OvahX7Y,389
 ara_cli/prompt_chat.py,sha256=kd_OINDQFit6jN04bb7mzgY259JBbRaTaNp9F-webkc,1346
-ara_cli/prompt_extractor.py,sha256=aY7k9JSfwwbhV3jiNmuijiLss1SlTJ1K_I3Q0sKK85U,7697
+ara_cli/prompt_extractor.py,sha256=6xLGd4ZJHDKkamEUQcdRbKM3ilBtxBjp0X2o8wrvHb0,7732
 ara_cli/prompt_handler.py,sha256=iulI3A4lHXvVITX7hiVN-pR61bzJmIfoYMGK_aO2Pfs,20248
 ara_cli/prompt_rag.py,sha256=ydlhe4CUqz0jdzlY7jBbpKaf_5fjMrAZKnriKea3ZAg,7485
 ara_cli/run_file_lister.py,sha256=XbrrDTJXp1LFGx9Lv91SNsEHZPP-PyEMBF_P4btjbDA,2360
 ara_cli/tag_extractor.py,sha256=TGdaQOVnjy25R0zDsAifB67C5oom0Fwo24s0_fr5A_I,3151
 ara_cli/template_manager.py,sha256=YwrN6AYPpl6ZrW8BVQpVXx8yTRf-oNpJUIKeg4NAggs,6606
 ara_cli/update_config_prompt.py,sha256=Oy9vNTw6UhDohyTEfSKkqE5ifEMPlmWNYkKHgUrK_pY,4607
-ara_cli/version.py,sha256=heZ4b9f4kN9C6UdfT0kjc10So52jou6EoLoEH2Yio3o,146
+ara_cli/version.py,sha256=HkAW6R4-z4t1cEYyw2ptaPZ3mSDYKamKl0luAnoY9WU,146
 ara_cli/artefact_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ara_cli/artefact_models/artefact_load.py,sha256=IXzWxP-Q_j_oDGMno0m-OuXCQ7Vd5c_NctshGr4ROBw,621
 ara_cli/artefact_models/artefact_mapping.py,sha256=8aD0spBjkJ8toMAmFawc6UTUxB6-tEEViZXv2I-r88Q,1874
@@ -53,6 +53,12 @@ ara_cli/commands/command.py,sha256=Y_2dNeuxRjbyI3ScXNv55lptSe8Hs_ya78L0nPYNZHA,1
 ara_cli/commands/extract_command.py,sha256=TfKuOnKQzJ8JPpJyKDm7qhm5mvbZnHspCem8g6YgACo,835
 ara_cli/commands/load_command.py,sha256=H3CfeHIL-criDU5oi4BONTSpyzJ4m8DzJ0ZCIiAZFeI,2204
 ara_cli/commands/load_image_command.py,sha256=g9-PXAYdqx5Ed1PdVo-FIb4CyJGEpRFbgQf9Dxg6DmM,886
+ara_cli/file_loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ara_cli/file_loaders/binary_file_loader.py,sha256=1HHH1Nk4lEM83CTnf4z9wYz6rMLgpxydFoRcSgkBHmQ,940
+ara_cli/file_loaders/document_file_loader.py,sha256=VxGFChYyM9K-e6eOCK3yk5jQuEXgz01Mh_NoA6CA_RM,1017
+ara_cli/file_loaders/document_reader.py,sha256=SD9_5-XJ6homKUes6o8GWcG--X63UslfAosPbrJZQvo,7721
+ara_cli/file_loaders/file_loader.py,sha256=bc1BrMG4pEtwsZLm3Ct53YsMPgnbSaEvZEd8isRDYRY,1711
+ara_cli/file_loaders/text_file_loader.py,sha256=x_ZqnOUb2glpdxziceWCBX8oEBk7JZhAluLRRvBjuQs,6626
 ara_cli/templates/agile.artefacts,sha256=nTA8dp98HWKAD-0qhmNpVYIfkVGoJshZqMJGnphiOsE,7932
 ara_cli/templates/template.businessgoal.prompt_log.md,sha256=xF6bkgj_GqAAqHxJWJiQNt11mEuSGemIqoZ2wOo6dI0,214
 ara_cli/templates/template.capability.prompt_log.md,sha256=eO8EzrHgb2vYJ-DP1jGzAfDlMo8nY75hZDfhh0s40uQ,208
@@ -146,8 +152,8 @@ tests/test_list_filter.py,sha256=fJA3d_SdaOAUkE7jn68MOVS0THXGghy1fye_64Zvo1U,796
 tests/test_tag_extractor.py,sha256=nSiAYlTKZ7TLAOtcJpwK5zTWHhFYU0tI5xKnivLc1dU,2712
 tests/test_template_manager.py,sha256=q-LMHRG4rHkD6ON6YW4cpZxUx9hul6Or8wVVRC2kb-8,4099
 tests/test_update_config_prompt.py,sha256=xsqj1WTn4BsG5Q2t-sNPfu7EoMURFcS-hfb5VSXUnJc,6765
-ara_cli-0.1.9.84.dist-info/METADATA,sha256=mXtpSamoGLgoHje7ri4iGBeK8lnCn1-v9oRkresNiws,6739
-ara_cli-0.1.9.84.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ara_cli-0.1.9.84.dist-info/entry_points.txt,sha256=v4h7MzysTgSIDYfEo3oj4Kz_8lzsRa3hq-KJHEcLVX8,45
-ara_cli-0.1.9.84.dist-info/top_level.txt,sha256=WM4cLHT5DYUaWzLtRj-gu3yVNFpGQ6lLRI3FMmC-38I,14
-ara_cli-0.1.9.84.dist-info/RECORD,,
+ara_cli-0.1.9.85.dist-info/METADATA,sha256=pA9IA0ZrgLUTuqgYcLbEHss01CZ3qdqaJ2Oo07IQppw,6739
+ara_cli-0.1.9.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ara_cli-0.1.9.85.dist-info/entry_points.txt,sha256=v4h7MzysTgSIDYfEo3oj4Kz_8lzsRa3hq-KJHEcLVX8,45
+ara_cli-0.1.9.85.dist-info/top_level.txt,sha256=WM4cLHT5DYUaWzLtRj-gu3yVNFpGQ6lLRI3FMmC-38I,14
+ara_cli-0.1.9.85.dist-info/RECORD,,