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

ara_cli/prompt_handler.py

@@ -60,7 +60,12 @@ class LLMSingleton:
         # Check if there was an authentication error
         stderr_output = captured_stderr.getvalue()
         if "Authentication error" in stderr_output:
-            warnings.warn("Invalid Langfuse credentials - prompt tracing disabled and using default prompts. Set environment variables 'ARA_CLI_LANGFUSE_PUBLIC_KEY', 'ARA_CLI_LANGFUSE_SECRET_KEY', 'LANGFUSE_HOST' and restart application to use Langfuse capabilities", UserWarning)
+            warnings.warn(
+                "Invalid Langfuse credentials - prompt tracing disabled and using default prompts. "
+                "Set environment variables 'ARA_CLI_LANGFUSE_PUBLIC_KEY', 'ARA_CLI_LANGFUSE_SECRET_KEY', "
+                "'LANGFUSE_HOST' and restart application to use Langfuse capabilities",
+                UserWarning,
+            )
 
         LLMSingleton._default_model = default_model_id
         LLMSingleton._extraction_model = extraction_model_id
@@ -160,6 +165,50 @@ def _is_valid_message(message: dict) -> bool:
     return False
 
 
+def _norm(p: str) -> str:
+    """Normalize slashes and collapse .. segments."""
+    return os.path.normpath(p) if p else p
+
+
+def resolve_existing_path(rel_or_abs_path: str, anchor_dir: str) -> str:
+    """
+    Resolve a potentially relative path to an existing absolute path.
+
+    Strategy:
+    - If already absolute and exists -> return it.
+    - Else, try from the anchor_dir.
+    - Else, walk up parent directories from anchor_dir and try joining at each level.
+    - If nothing is found, return the normalized original (will fail later with clear message).
+    """
+    if not rel_or_abs_path:
+        return rel_or_abs_path
+
+    candidate = _norm(rel_or_abs_path)
+
+    if os.path.isabs(candidate) and os.path.exists(candidate):
+        return candidate
+
+    anchor_dir = os.path.abspath(anchor_dir or os.getcwd())
+
+    # Try from anchor dir directly
+    direct = _norm(os.path.join(anchor_dir, candidate))
+    if os.path.exists(direct):
+        return direct
+
+    # Walk parents
+    cur = anchor_dir
+    prev = None
+    while cur and cur != prev:
+        test = _norm(os.path.join(cur, candidate))
+        if os.path.exists(test):
+            return test
+        prev = cur
+        cur = os.path.dirname(cur)
+
+    # Give back normalized candidate; open() will raise, but at least path is clean
+    return candidate
+
+
 def send_prompt(prompt, purpose="default"):
     """Prepares and sends a prompt to the LLM, streaming the response."""
     chat_instance = LLMSingleton.get_instance()
@@ -213,8 +262,6 @@ def describe_image(image_path: str) -> str:
     Returns:
         Text description of the image
     """
-    import base64
-
     with LLMSingleton.get_instance().langfuse.start_as_current_span(
         name="ara-cli/describe-image"
     ) as span:
@@ -234,14 +281,19 @@ def describe_image(image_path: str) -> str:
         # 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, describe what you see."
+            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, "
+                "describe what you see."
+            )
 
-        # Read and encode the image
-        with open(image_path, "rb") as image_file:
+        # Resolve and read the image
+        resolved_image_path = resolve_existing_path(image_path, os.getcwd())
+        with open(resolved_image_path, "rb") as image_file:
             base64_image = base64.b64encode(image_file.read()).decode("utf-8")
 
         # Determine image type
-        image_extension = os.path.splitext(image_path)[1].lower()
+        image_extension = os.path.splitext(resolved_image_path)[1].lower()
         mime_type = {
             ".png": "image/png",
             ".jpg": "image/jpeg",
@@ -256,7 +308,7 @@ def describe_image(image_path: str) -> str:
             "content": [
                 {
                     "type": "text",
-                    "text": "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, describe what you see.",
+                    "text": describe_image_prompt,
                 },
                 {
                     "type": "image_url",
@@ -288,7 +340,9 @@ def describe_image(image_path: str) -> str:
 def append_headings(classifier, param, heading_name):
     sub_directory = Classifier.get_sub_directory(classifier)
 
-    artefact_data_path = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    artefact_data_path = _norm(
+        f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    )
 
     # Check if the file exists, and if not, create an empty file
     if not os.path.exists(artefact_data_path):
@@ -309,15 +363,15 @@ def append_headings(classifier, param, heading_name):
 
 def write_prompt_result(classifier, param, text):
     sub_directory = Classifier.get_sub_directory(classifier)
-
-    # TODO change absolute path to relative path with directory navigator
-    artefact_data_path = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    artefact_data_path = _norm(
+        f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
+    )
     write_string_to_file(artefact_data_path, text, "a")
 
 
 def prompt_data_directory_creation(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     if not exists(prompt_data_path):
         makedirs(prompt_data_path)
     return prompt_data_path
@@ -347,9 +401,10 @@ def initialize_prompt_templates(classifier, parameter):
         artefact_to_mark=f"{parameter}.{classifier}",
     )
 
-    generate_config_prompt_global_givens_file(prompt_data_path, "config.prompt_global_givens.md")
-
-    generate_config_prompt_global_givens_file(prompt_data_path, "config.prompt_global_givens.md")
+    # Only once (was duplicated before)
+    generate_config_prompt_global_givens_file(
+        prompt_data_path, "config.prompt_global_givens.md"
+    )
 
 
 def write_template_files_to_config(template_type, config_file, base_template_path):
@@ -361,7 +416,7 @@ def write_template_files_to_config(template_type, config_file, base_template_pat
 
 def load_selected_prompt_templates(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     config_file_path = os.path.join(prompt_data_path, "config.prompt_templates.md")
 
     if not os.path.exists(config_file_path):
@@ -464,7 +519,9 @@ def move_and_copy_files(source_path, prompt_data_path, prompt_archive_path):
 
 def extract_and_load_markdown_files(md_prompt_file_path):
     """
-    Extracts markdown files paths based on checked items and constructs proper paths respecting markdown header hierarchy.
+    Extracts markdown files paths based on checked items and constructs proper paths
+    respecting markdown header hierarchy. **Returns normalized relative paths**
+    (not resolved), and resolution happens later relative to the config file dir.
     """
     header_stack = []
     path_accumulator = []
@@ -480,53 +537,73 @@ def extract_and_load_markdown_files(md_prompt_file_path):
                 header_stack.append(header)
             elif "[x]" in line:
                 relative_path = line.split("]")[-1].strip()
-                full_path = os.path.join("/".join(header_stack), relative_path)
-                path_accumulator.append(full_path)
+                # 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
+                path_accumulator.append(_norm(full_rel_path))
     return path_accumulator
 
 
 def load_givens(file_path):
+    """
+    Reads marked givens from a config markdown and returns:
+      - combined markdown content (including code fences / images)
+      - a list of image data dicts for the multimodal message
+    Paths inside the markdown are resolved robustly relative to the config file directory (and its parents).
+    """
     content = ""
     image_data_list = []
     markdown_items = extract_and_load_markdown_files(file_path)
 
-    # Only proceed and add the header if there are marked items to load.
     if not markdown_items:
         return "", []
 
     content = "### GIVENS\n\n"
 
+    anchor_dir = os.path.dirname(os.path.abspath(file_path))
+
     for item in markdown_items:
-        if item.lower().endswith((".png", ".jpeg", ".jpg")):
-            with open(item, "rb") as image_file:
+        resolved = resolve_existing_path(item, anchor_dir)
+        # Keep the listing line readable, show the original relative item
+        content += item + "\n"
+
+        ext = os.path.splitext(resolved)[1].lower()
+
+        # Image branch
+        if ext in (".png", ".jpeg", ".jpg", ".gif", ".bmp"):
+            with open(resolved, "rb") as image_file:
                 base64_image = base64.b64encode(image_file.read()).decode("utf-8")
+
+            mime_type = {
+                ".png": "image/png",
+                ".jpg": "image/jpeg",
+                ".jpeg": "image/jpeg",
+                ".gif": "image/gif",
+                ".bmp": "image/bmp",
+            }.get(ext, "image/png")
+
             image_data_list.append(
                 {
                     "type": "image_url",
-                    "image_url": {"url": f"data:image/png;base64,{base64_image}"},
+                    "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
                 }
             )
-            content += item + "\n"
-            content += f"![{item}](data:image/png;base64,{base64_image})" + "\n"
-        else:
-            # Check if the item specifies line ranges
-            # TODO item has currently no trailing [] see extraction and handover method in extract and load
-            # item = f"[10:29] {item}"
-            # print(f"found {item}, check for subsection")
-            # TODO re.match can not split the item with [] correctly and extract the line numbers
-            # TODO logic of subsections is not supported by the update algorithm of the config prompt givens updater
-            # TODO extract in lines of *.md files potential images and add them to the image list
+            # Also embed inline for the prompt markdown (use png as a neutral default for data URI)
+            content += f"![{item}](data:{mime_type};base64,{base64_image})\n"
 
+        else:
+            # Check if the item specifies line ranges: e.g. "[10:20,25:30] filePath"
             match = re.match(r".*?\[(\d+:\d+(?:,\s*\d+:\d+)*)\]\s+(.+)", item)
             if match:
                 line_ranges, file_name = match.groups()
-                content += file_name + "\n" + "```\n"
-                content += get_partial_file_content(file_name, line_ranges) + "\n"
+                resolved_sub = resolve_existing_path(file_name, anchor_dir)
+                content += "```\n"
+                content += get_partial_file_content(resolved_sub, line_ranges) + "\n"
                 content += "```\n\n"
             else:
-                content += item + "\n" + "```\n"
-                content += get_file_content(item) + "\n"
+                content += "```\n"
+                content += get_file_content(resolved) + "\n"
                 content += "```\n\n"
+
     return content, image_data_list
 
 
@@ -535,7 +612,7 @@ def get_partial_file_content(file_name, line_ranges):
     Reads specific lines from a file based on the line ranges provided.
 
     Args:
-    file_name (str): The path to the file.
+    file_name (str): The path to the file (absolute or relative, already resolved by caller).
     line_ranges (str): A string representing the line ranges to read, e.g., '10:20,25:30'.
 
     Returns:
@@ -585,9 +662,7 @@ def prepend_system_prompt(message_list):
     # 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}
@@ -597,6 +672,9 @@ def prepend_system_prompt(message_list):
 
 
 def append_images_to_message(message, image_data_list):
+    """
+    Appends image data list to a single message dict (NOT to a list).
+    """
     logger = logging.getLogger(__name__)
 
     logger.debug(
@@ -607,13 +685,17 @@ def append_images_to_message(message, image_data_list):
         logger.debug("No images to append, returning original message")
         return message
 
-    message_content = message["content"]
+    message_content = message.get("content")
     logger.debug(f"Original message content: {message_content}")
 
     if isinstance(message_content, str):
         message["content"] = [{"type": "text", "text": message_content}]
 
-    message["content"].extend(image_data_list)
+    if isinstance(message["content"], 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
 
     logger.debug(f"Updated message content with {len(image_data_list)} images")
 
@@ -622,11 +704,20 @@ def append_images_to_message(message, image_data_list):
 
 def create_and_send_custom_prompt(classifier, parameter):
     sub_directory = Classifier.get_sub_directory(classifier)
-    prompt_data_path = f"ara/{sub_directory}/{parameter}.data/prompt.data"
+    prompt_data_path = _norm(f"ara/{sub_directory}/{parameter}.data/prompt.data")
     prompt_file_path_markdown = join(prompt_data_path, f"{classifier}.prompt.md")
 
-    extensions = [".blueprint.md", ".rules.md", ".prompt_givens.md", ".prompt_global_givens.md", ".intention.md", ".commands.md"]
-    combined_content_markdown, image_data_list = collect_file_content_by_extension(prompt_data_path, extensions)
+    extensions = [
+        ".blueprint.md",
+        ".rules.md",
+        ".prompt_givens.md",
+        ".prompt_global_givens.md",
+        ".intention.md",
+        ".commands.md",
+    ]
+    combined_content_markdown, image_data_list = collect_file_content_by_extension(
+        prompt_data_path, extensions
+    )
 
     with open(prompt_file_path_markdown, "w", encoding="utf-8") as file:
         file.write(combined_content_markdown)
@@ -635,14 +726,14 @@ def create_and_send_custom_prompt(classifier, parameter):
     append_headings(classifier, parameter, "prompt")
     write_prompt_result(classifier, parameter, prompt)
 
+    # Build message and append images correctly (fixed)
     message = {"role": "user", "content": combined_content_markdown}
-
+    message = append_images_to_message(message, image_data_list)
     message_list = [message]
 
-    message_list = append_images_to_message(message_list, image_data_list)
     append_headings(classifier, parameter, "result")
 
-    artefact_data_path = (
+    artefact_data_path = _norm(
         f"ara/{sub_directory}/{parameter}.data/{classifier}.prompt_log.md"
     )
     with open(artefact_data_path, "a", encoding="utf-8") as file:
@@ -652,7 +743,6 @@ def create_and_send_custom_prompt(classifier, parameter):
                 continue
             file.write(chunk_content)
             file.flush()
-    # write_prompt_result(classifier, parameter, response)
 
 
 def generate_config_prompt_template_file(
@@ -661,7 +751,8 @@ def generate_config_prompt_template_file(
     config_prompt_templates_path = os.path.join(
         prompt_data_path, config_prompt_templates_name
     )
-    config = ConfigManager.get_config()
+    # Use instance method consistently
+    config = ConfigManager().get_config()
     global_prompt_template_path = TemplatePathManager.get_template_base_path()
     dir_list = ["ara/.araconfig/custom-prompt-modules"] + [
         f"{os.path.join(global_prompt_template_path,'prompt-modules')}"
@@ -678,7 +769,7 @@ def generate_config_prompt_givens_file(
     config_prompt_givens_path = os.path.join(
         prompt_data_path, config_prompt_givens_name
     )
-    config = ConfigManager.get_config()
+    config = ConfigManager().get_config()
     dir_list = (
         ["ara"]
         + [path for d in config.ext_code_dirs for path in d.values()]
@@ -712,14 +803,24 @@ def generate_config_prompt_givens_file(
         with open(config_prompt_givens_path, "w", encoding="utf-8") as file:
             file.write("".join(updated_listing))
 
-def generate_config_prompt_global_givens_file(prompt_data_path, config_prompt_givens_name, artefact_to_mark=None):
+
+def generate_config_prompt_global_givens_file(
+    prompt_data_path, config_prompt_givens_name, artefact_to_mark=None
+):
     from ara_cli.global_file_lister import generate_global_markdown_listing
-    config_prompt_givens_path = os.path.join(prompt_data_path, config_prompt_givens_name)
-    config = ConfigManager.get_config()
 
-    if not hasattr(config, 'global_dirs') or not config.global_dirs:
+    config_prompt_givens_path = os.path.join(
+        prompt_data_path, config_prompt_givens_name
+    )
+    config = ConfigManager().get_config()
+
+    if not hasattr(config, "global_dirs") or not config.global_dirs:
         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")
-    generate_global_markdown_listing(dir_list, config.ara_prompt_given_list_includes, config_prompt_givens_path)
+    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,18 +6,17 @@ 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
 
-    def filter_column(self, tags_set, filtered_artefacts):
+    def filter_column(self, tag_groups, filtered_artefacts):
         status_tags = {"to-do", "in-progress", "review", "done", "closed"}
 
         artefacts_to_process = self._get_artefacts_without_status_tags(
             filtered_artefacts, status_tags
         )
-        self._add_non_status_tags_to_set(tags_set, artefacts_to_process, status_tags)
+        self._add_non_status_tags_to_set(tag_groups, artefacts_to_process, status_tags)
 
     def _get_artefacts_without_status_tags(self, filtered_artefacts, status_tags):
         artefacts_to_process = []
@@ -32,7 +31,7 @@ class TagExtractor:
         tags = artefact.tags + [artefact.status] if artefact.status else artefact.tags
         return set(tag for tag in tags if tag is not None)
 
-    def _add_non_status_tags_to_set(self, tags_set, artefacts, status_tags):
+    def _add_non_status_tags_to_set(self, tag_groups, artefacts, status_tags):
         for artefact in artefacts:
             tags = [
                 tag for tag in (artefact.tags + [artefact.status]) if tag is not None
@@ -40,23 +39,45 @@ class TagExtractor:
             for tag in tags:
                 if self._is_skipped_tag(tag, status_tags):
                     continue
-                tags_set.add(tag)
+                key = tag.lower()
+                if key not in tag_groups:
+                    tag_groups[key] = set()
+                tag_groups[key].add(tag)
 
     def _is_skipped_tag(self, tag, status_tags):
         return (
             tag in status_tags or tag.startswith("priority_") or tag.startswith("user_")
         )
 
-    def add_to_tags_set(self, tags_set, filtered_artefacts):
+    def _collect_all_tags(self, artefact):
+        """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:
+            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):
+        """Add tags to tag groups."""
+        for tag in tags:
+            key = tag.lower()
+            if key not in tag_groups:
+                tag_groups[key] = set()
+            tag_groups[key].add(tag)
+
+    def add_to_tags_set(self, tag_groups, filtered_artefacts):
         for artefact_list in filtered_artefacts.values():
             for artefact in artefact_list:
-                user_tags = [f"user_{tag}" for tag in artefact.users]
-                tags = [
-                    tag
-                    for tag in (artefact.tags + [artefact.status] + user_tags)
-                    if tag is not None
-                ]
-                tags_set.update(tags)
+                all_tags = self._collect_all_tags(artefact)
+                self._add_tags_to_groups(tag_groups, all_tags)
 
     def extract_tags(
         self,
@@ -81,12 +102,11 @@ class TagExtractor:
             tag_retrieval=artefact_tags_retrieval,
         )
 
-        unique_tags = set()
+        tag_groups = {}
 
         if filtered_extra_column:
-            self.filter_column(unique_tags, filtered_artefacts)
+            self.filter_column(tag_groups, filtered_artefacts)
         else:
-            self.add_to_tags_set(unique_tags, filtered_artefacts)
+            self.add_to_tags_set(tag_groups, filtered_artefacts)
 
-        sorted_tags = sorted(unique_tags)
-        return sorted_tags
+        return tag_groups

ara_cli/template_loader.py

@@ -4,6 +4,7 @@ import glob
 from ara_cli.template_manager import TemplatePathManager
 from ara_cli.ara_config import ConfigManager
 from ara_cli.directory_navigator import DirectoryNavigator
+from . import ROLE_PROMPT
 
 
 class TemplateLoader:
@@ -147,7 +148,7 @@ class TemplateLoader:
             # Direct file loading for CLI usage
             try:
                 with open(file_path, 'r', encoding='utf-8') as template_file:
-                    template_content = template_file.read()
+                    template_content = template_file.read().replace('\r\n', '\n')
 
                 # Add prompt tag if needed
                 self._add_prompt_tag_if_needed(chat_file_path)
@@ -171,7 +172,7 @@ class TemplateLoader:
         with open(chat_file_path, 'r', encoding='utf-8') as file:
             lines = file.readlines()
 
-        prompt_tag = f"# {Chat.ROLE_PROMPT}:"
+        prompt_tag = f"# {ROLE_PROMPT}:"
         if Chat.get_last_role_marker(lines) == prompt_tag:
             return