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

ara_cli/file_loaders/readers/docx_reader.py

@@ -0,0 +1,49 @@
+from ara_cli.file_loaders.document_reader import DocumentReader
+
+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

ara_cli/file_loaders/readers/excel_reader.py

@@ -0,0 +1,27 @@
+from ara_cli.file_loaders.document_reader import DocumentReader
+
+class ExcelReader(DocumentReader):
+    """Reader for Excel files"""
+
+    def read(self, extract_images: bool = False) -> str:
+        import pandas as pd
+
+        try:
+            # Read all sheets
+            sheets_dict = pd.read_excel(self.file_path, sheet_name=None)
+            markdown_output = []
+
+            for sheet_name, df in sheets_dict.items():
+                markdown_output.append(f"### Sheet: {sheet_name}")
+                if df.empty:
+                    markdown_output.append("_Empty Sheet_")
+                else:
+                    # Convert to markdown, managing NaN values
+                    markdown_table = df.fillna("").to_markdown(index=False)
+                    markdown_output.append(markdown_table)
+                markdown_output.append("")  # Add empty line between sheets
+
+            return "\n".join(markdown_output)
+
+        except Exception as e:
+            return f"Error reading Excel file: {str(e)}"

ara_cli/file_loaders/{markdown_reader.py → readers/markdown_reader.py}

@@ -2,7 +2,7 @@ import os
 import re
 from typing import Optional
 from charset_normalizer import from_path
-from ara_cli.file_loaders.image_processor import ImageProcessor
+from ara_cli.file_loaders.tools.image_processor import ImageProcessor
 
 
 class MarkdownReader:

ara_cli/file_loaders/readers/odt_reader.py

@@ -0,0 +1,59 @@
+from ara_cli.file_loaders.document_reader import DocumentReader
+
+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

ara_cli/file_loaders/readers/pdf_reader.py

@@ -0,0 +1,54 @@
+from ara_cli.file_loaders.document_reader import DocumentReader
+
+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

ara_cli/file_loaders/readers/pptx_reader.py

@@ -0,0 +1,104 @@
+from ara_cli.file_loaders.document_reader import DocumentReader
+
+
+class PptxReader(DocumentReader):
+    """Reader for PowerPoint files"""
+
+    @staticmethod
+    def _getActionImage(shape, MSO_SHAPE_TYPE):
+        try:
+            if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+                return shape.image.blob, shape.image.ext
+            elif shape.is_placeholder and hasattr(shape, "image"):
+                return shape.image.blob, shape.image.ext
+        except Exception:
+            pass
+        return None, None
+
+    @staticmethod
+    def _get_shape_text(shape, slide):
+        if not shape.has_text_frame:
+            return []
+
+        lines = []
+        is_title = False
+        try:
+            if shape == slide.shapes.title:
+                is_title = True
+        except AttributeError:
+            pass
+
+        text_frame = shape.text_frame
+        if is_title:
+            lines.append(f"### {text_frame.text}")
+        else:
+            for paragraph in text_frame.paragraphs:
+                text = paragraph.text.strip()
+                if text:
+                    lines.append(f"- {text}")
+        return lines
+
+    def read(self, extract_images: bool = False) -> str:
+        from pptx import Presentation
+        from pptx.enum.shapes import MSO_SHAPE_TYPE
+        import io
+
+        try:
+            prs = Presentation(self.file_path)
+            md_lines = []
+
+            # Prepare image extraction if requested
+            images_dir = None
+            image_counter = 1
+            image_descriptions = []
+
+            if extract_images:
+                images_dir = self.create_image_data_dir("pptx")
+
+            def process_shape(shape):
+                # Recursive function to handle groups and extract images
+                if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+                    for sub_shape in shape.shapes:
+                        process_shape(sub_shape)
+                    return
+
+                # Text extraction
+                md_lines.extend(self._get_shape_text(shape, slide))
+
+                # Image extraction
+                if extract_images:
+                    blob, ext = self._getActionImage(shape, MSO_SHAPE_TYPE)
+                    if blob and ext:
+                        try:
+                            nonlocal image_counter
+                            relative_path, description = self.save_and_describe_image(
+                                blob, ext, images_dir, image_counter
+                            )
+                            image_desc_text = (
+                                f"\nImage: {relative_path}\n[{description}]\n"
+                            )
+                            md_lines.append(image_desc_text)
+                            image_descriptions.append(image_desc_text)
+                            image_counter += 1
+                        except Exception as img_err:
+                            print(
+                                f"Warning: Failed to extract image from slide {index+1}: {img_err}"
+                            )
+
+            for index, slide in enumerate(prs.slides):
+                md_lines.append(f"## Slide {index + 1}")
+
+                # Collect shapes and sort by top position
+                shapes = sorted(
+                    [s for s in slide.shapes], key=lambda x: (x.top or 0, x.left or 0)
+                )
+
+                for shape in shapes:
+                    process_shape(shape)
+
+                md_lines.append("\n---\n")
+
+            return "\n".join(md_lines)
+
+        except Exception as e:
+            return f"Error reading PowerPoint file: {str(e)}"

ara_cli/output_suppressor.py

@@ -15,3 +15,56 @@ def suppress_stdout(suppress=False):
                 sys.stdout = old_stdout
     else:
         yield
+
+
+@contextmanager
+def suppress_stderr():
+    """Suppress stderr output - useful for hiding library debug/error messages."""
+    with open(os.devnull, "w", encoding="utf-8") as devnull:
+        old_stderr = sys.stderr
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stderr = old_stderr
+
+
+class FilteredStdout:
+    """A stdout wrapper that filters out specific unwanted messages."""
+    
+    FILTERED_PATTERNS = [
+        "Provider List: https://docs.litellm.ai/docs/providers",
+    ]
+    
+    def __init__(self, original_stdout):
+        self.original_stdout = original_stdout
+    
+    def write(self, text):
+        # Check if text contains any filtered patterns
+        for pattern in self.FILTERED_PATTERNS:
+            if pattern in text:
+                return  # Suppress this output
+        self.original_stdout.write(text)
+    
+    def flush(self):
+        self.original_stdout.flush()
+    
+    def __getattr__(self, name):
+        return getattr(self.original_stdout, name)
+
+
+@contextmanager
+def filter_unwanted_output():
+    """Filter out unwanted stdout messages and suppress stderr."""
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    
+    sys.stdout = FilteredStdout(old_stdout)
+    
+    with open(os.devnull, "w", encoding="utf-8") as devnull:
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr

ara_cli/prompt_handler.py

@@ -10,15 +10,79 @@ import logging
 import warnings
 from io import StringIO
 from contextlib import redirect_stderr
-from langfuse import Langfuse
-from langfuse.api.resources.commons.errors import Error as LangfuseError, NotFoundError
-import litellm
 from ara_cli.classifier import Classifier
 from ara_cli.artefact_creator import ArtefactCreator
 from ara_cli.template_manager import TemplatePathManager
 from ara_cli.ara_config import ConfigManager
 from ara_cli.file_lister import generate_markdown_listing
 
+# Lazy loading for heavy modules - these will be imported on first use
+# Module-level references for backward compatibility with tests that patch these
+litellm = None  # Will be lazily loaded
+Langfuse = None  # Will be lazily loaded
+_logging_configured = False
+
+
+def _configure_logging():
+    """Configure logging for litellm/langfuse - called once on first LLM use."""
+    global _logging_configured
+    if _logging_configured:
+        return
+    _logging_configured = True
+
+    logging.getLogger("LiteLLM").setLevel(logging.CRITICAL)
+    logging.getLogger("litellm").setLevel(logging.CRITICAL)
+    logging.getLogger("LiteLLM Proxy").setLevel(logging.CRITICAL)
+    logging.getLogger("LiteLLM Router").setLevel(logging.CRITICAL)
+    logging.getLogger("langfuse").setLevel(logging.CRITICAL)
+    logging.getLogger("opentelemetry").setLevel(logging.CRITICAL)
+    logging.getLogger("opentelemetry.exporter.otlp.proto.http.trace_exporter").setLevel(
+        logging.CRITICAL
+    )
+    logging.getLogger("httpx").setLevel(logging.CRITICAL)
+    logging.getLogger("httpcore").setLevel(logging.CRITICAL)
+
+
+def _get_litellm():
+    """Lazy load litellm module."""
+    global litellm
+    if litellm is None:
+        _configure_logging()
+        import litellm as _litellm
+
+        _litellm.suppress_debug_info = True
+        _litellm.set_verbose = False
+        litellm = _litellm
+
+        # Apply output filtering only when litellm is loaded
+        from ara_cli.output_suppressor import FilteredStdout
+        import sys
+
+        if not isinstance(sys.stdout, FilteredStdout):
+            sys.stdout = FilteredStdout(sys.stdout)
+    return litellm
+
+
+def _get_langfuse():
+    """Lazy load langfuse module."""
+    global Langfuse
+    if Langfuse is None:
+        _configure_logging()
+        from langfuse import Langfuse as _Langfuse
+
+        Langfuse = _Langfuse
+    return Langfuse
+
+
+def _get_langfuse_errors():
+    """Lazy load langfuse error classes."""
+    from langfuse.api.resources.commons.errors import (
+        Error as LangfuseError,
+        NotFoundError,
+    )
+
+    return LangfuseError, NotFoundError
+
 
 class LLMSingleton:
     _instance = None
@@ -51,6 +115,7 @@ class LLMSingleton:
 
         captured_stderr = StringIO()
         with redirect_stderr(captured_stderr):
+            Langfuse = _get_langfuse()
             self.langfuse = Langfuse(
                 public_key=langfuse_public_key,
                 secret_key=langfuse_secret_key,
@@ -218,14 +283,43 @@ def send_prompt(prompt, purpose="default"):
     with LLMSingleton.get_instance().langfuse.start_as_current_span(
         name="send_prompt"
     ) as span:
+        # Sanitize prompt for logging (remove base64 image data)
+        def sanitize_message(msg):
+            import copy
+
+            if not isinstance(msg, dict):
+                return msg
+
+            clean_msg = copy.deepcopy(msg)
+            content = clean_msg.get("content")
+
+            if isinstance(content, list):
+                new_content = []
+                for item in content:
+                    if item.get("type") == "image_url":
+                        # Replace image_url with text placeholder to avoid Langfuse parsing errors on invalid base64
+                        new_content.append(
+                            {
+                                "type": "text",
+                                "text": "[IMAGE DATA TRUNCATED FOR LOGGING]",
+                            }
+                        )
+                    else:
+                        new_content.append(item)
+                clean_msg["content"] = new_content
+            return clean_msg
+
+        sanitized_prompt = [sanitize_message(msg) for msg in prompt]
+
         span.update_trace(
-            input={"prompt": prompt, "purpose": purpose, "model": model_info}
+            input={"prompt": sanitized_prompt, "purpose": purpose, "model": model_info}
         )
 
         config_parameters.pop("provider", None)
 
         filtered_prompt = [msg for msg in prompt if _is_valid_message(msg)]
 
+        litellm = _get_litellm()
         completion = litellm.completion(
             **config_parameters, messages=filtered_prompt, stream=True
         )
@@ -274,13 +368,12 @@ def describe_image(image_path: str) -> str:
             describe_image_prompt = (
                 langfuse_prompt.prompt if langfuse_prompt.prompt else None
             )
-        except (LangfuseError, NotFoundError, Exception) as e:
-            logging.info(f"Could not fetch Langfuse prompt: {e}")
+        except Exception as e:
+            # Silently fallback - no need to show error for describe-image prompt
             describe_image_prompt = None
 
         # Fallback to default prompt if Langfuse prompt is not available
         if not describe_image_prompt:
-            logging.info("Using default describe-image prompt.")
             describe_image_prompt = (
                 "Please describe this image in detail. If it contains text, transcribe it exactly. "
                 "If it's a diagram or chart, explain its structure and content. If it's a photo or illustration, "
@@ -538,7 +631,11 @@ def extract_and_load_markdown_files(md_prompt_file_path):
             elif "[x]" in line:
                 relative_path = line.split("]")[-1].strip()
                 # Use os.path.join for OS-safe joining, then normalize
-                full_rel_path = os.path.join(*header_stack, relative_path) if header_stack else relative_path
+                full_rel_path = (
+                    os.path.join(*header_stack, relative_path)
+                    if header_stack
+                    else relative_path
+                )
                 path_accumulator.append(_norm(full_rel_path))
     return path_accumulator
 
@@ -650,19 +747,28 @@ def collect_file_content_by_extension(prompt_data_path, extensions):
 
 
 def prepend_system_prompt(message_list):
+    from ara_cli.error_handler import AraError, ErrorLevel, ErrorHandler
+
     try:
         langfuse_prompt = LLMSingleton.get_instance().langfuse.get_prompt(
             "ara-cli/system-prompt"
         )
         system_prompt = langfuse_prompt.prompt if langfuse_prompt.prompt else None
-    except (LangfuseError, NotFoundError, Exception) as e:
-        logging.info(f"Could not fetch Langfuse system prompt: {e}")
+    except Exception as e:
+        # Show user-friendly info message about Langfuse connection issue
+        info_error = AraError(
+            message="Langfuse connection failed. Using default system prompt.",
+            error_code=0,
+            level=ErrorLevel.INFO,
+        )
+        ErrorHandler().report_error(info_error)
         system_prompt = None
 
     # Fallback to default prompt if Langfuse prompt is not available
     if not system_prompt:
-        logging.info("Using default system prompt.")
-        system_prompt = "You are a helpful assistant that can process both text and images."
+        system_prompt = (
+            "You are a helpful assistant that can process both text and images."
+        )
 
     # Prepend the system prompt
     system_prompt_message = {"role": "system", "content": system_prompt}
@@ -695,7 +801,9 @@ def append_images_to_message(message, image_data_list):
         message["content"].extend(image_data_list)
     else:
         # If somehow content is not list or str, coerce to list
-        message["content"] = [{"type": "text", "text": str(message_content)}] + image_data_list
+        message["content"] = [
+            {"type": "text", "text": str(message_content)}
+        ] + image_data_list
 
     logger.debug(f"Updated message content with {len(image_data_list)} images")
 
@@ -818,9 +926,7 @@ def generate_config_prompt_global_givens_file(
         return
 
     dir_list = [path for d in config.global_dirs for path in d.values()]
-    print(
-        f"used {dir_list} for global prompt givens file listing with absolute paths"
-    )
+    print(f"used {dir_list} for global prompt givens file listing with absolute paths")
     generate_global_markdown_listing(
         dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path
-    )
+    )

ara_cli/tag_extractor.py

@@ -6,6 +6,7 @@ from ara_cli.artefact_models.artefact_data_retrieval import (
     artefact_tags_retrieval,
 )
 
+
 class TagExtractor:
     def __init__(self, file_system=None):
         self.file_system = file_system or os
@@ -53,16 +54,16 @@ class TagExtractor:
         """Collect all tags from an artefact including user tags and author."""
         all_tags = []
         all_tags.extend(artefact.tags)
-        
+
         if artefact.status:
             all_tags.append(artefact.status)
-            
+
         user_tags = [f"user_{tag}" for tag in artefact.users]
         all_tags.extend(user_tags)
-        
-        if hasattr(artefact, 'author') and artefact.author:
+
+        if hasattr(artefact, "author") and artefact.author:
             all_tags.append(artefact.author)
-            
+
         return [tag for tag in all_tags if tag is not None]
 
     def _add_tags_to_groups(self, tag_groups, tags):
@@ -92,7 +93,7 @@ class TagExtractor:
         if navigate_to_target:
             navigator.navigate_to_target()
 
-        artefacts = ArtefactReader.read_artefacts()
+        artefacts = ArtefactReader(self.file_system).read_artefacts()
 
         filtered_artefacts = filter_list(
             list_to_filter=artefacts,
@@ -109,4 +110,4 @@ class TagExtractor:
         else:
             self.add_to_tags_set(tag_groups, filtered_artefacts)
 
-        return tag_groups
+        return tag_groups

ara_cli/version.py

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

{ara_cli-0.1.13.3.dist-info → ara_cli-0.1.14.0.dist-info}/METADATA

@@ -1,28 +1,34 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.13.3
+Version: 0.1.14.0
 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: argcomplete
+Requires-Dist: argparse
+Requires-Dist: cmd2>=2.5
+Requires-Dist: rich
+Requires-Dist: typer
 Requires-Dist: langfuse
-Requires-Dist: litellm
+Requires-Dist: litellm>=1.81.0
 Requires-Dist: llama-index
 Requires-Dist: llama-index-llms-openai
 Requires-Dist: llama-index-retrievers-bm25
 Requires-Dist: openai
-Requires-Dist: markdown-it-py
-Requires-Dist: json-repair
-Requires-Dist: argparse
-Requires-Dist: argcomplete
-Requires-Dist: cmd2>=2.5
-Requires-Dist: charset-normalizer
-Requires-Dist: pydantic
 Requires-Dist: pydantic_ai
-Requires-Dist: python-docx
+Requires-Dist: charset-normalizer
+Requires-Dist: json-repair
+Requires-Dist: markdown-it-py
+Requires-Dist: openpyxl
+Requires-Dist: xlrd
+Requires-Dist: xlwt
+Requires-Dist: pandas
 Requires-Dist: pymupdf4llm
-Requires-Dist: typer
+Requires-Dist: python-docx
+Requires-Dist: python-pptx
+Requires-Dist: tabulate
 Requires-Dist: psutil
+Requires-Dist: pydantic
 Requires-Dist: requests
-Requires-Dist: rich
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist