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

ara_cli/prompt_extractor.py

@@ -8,20 +8,89 @@ 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 _find_extract_token(tokens):
+    """Find the first token that needs to be processed."""
+    for token in tokens:
+        if token.type == 'fence' and token.content.strip().startswith("# [x] extract"):
+            return token
+    return None
+
+def _extract_file_path(content_lines):
+    """Extract file path from content lines."""
+    if not content_lines:
+        return None
+    file_path_search = re.search(r"# filename: (.+)", content_lines[0])
+    return file_path_search.group(1).strip() if file_path_search else None
+
+def _find_artefact_class(content_lines):
+    """Find the appropriate artefact class from content lines."""
+    for line in content_lines[:2]:
+        words = line.strip().split(' ')
+        if not words:
+            continue
+        first_word = words[0]
+        if first_word in title_prefix_to_artefact_class:
+            return title_prefix_to_artefact_class[first_word]
+    return None
+
+def _process_file_extraction(file_path, code_content, force, write):
+    """Process file extraction logic."""
+    print(f"Filename extracted: {file_path}")
+    handle_existing_file(file_path, code_content, force, write)
+
+def _process_artefact_extraction(artefact_class, content_lines, force, write):
+    """Process artefact extraction logic."""
+    artefact = artefact_class.deserialize('\n'.join(content_lines))
+    serialized_artefact = artefact.serialize()
+
+    original_directory = os.getcwd()
+    directory_navigator = DirectoryNavigator()
+    directory_navigator.navigate_to_target()
+
+    artefact_path = artefact.file_path
+    directory = os.path.dirname(artefact_path)
+    os.makedirs(directory, exist_ok=True)
+    handle_existing_file(artefact_path, serialized_artefact, force, write)
+
+    os.chdir(original_directory)
+
+def _process_extraction_block(token_to_process, updated_content, force, write):
+    """Process a single extraction block."""
+    # Get the original block text for later replacement
+    source_lines = updated_content.split('\n')
+    start_line, end_line = token_to_process.map
+    original_block_text = '\n'.join(source_lines[start_line:end_line])
+
+    block_content = token_to_process.content
+    block_lines = block_content.split('\n')
+    content_lines_after_extract = block_lines[1:]
+
+    file_path = _extract_file_path(content_lines_after_extract)
+
+    if file_path:
+        code_content = '\n'.join(content_lines_after_extract[1:])
+        _process_file_extraction(file_path, code_content, force, write)
+    else:
+        artefact_class = _find_artefact_class(content_lines_after_extract)
+        if artefact_class:
+            _process_artefact_extraction(artefact_class, content_lines_after_extract, force, write)
+        else:
+            print("No filename or valid artefact found, skipping processing for this block.")
 
-def extract_code_blocks_md(markdown_text):
-    md = MarkdownIt()
-    tokens = md.parse(markdown_text)
-    code_blocks = [token.content for token in tokens if token.type == 'fence']
-    return code_blocks
-
+    # Update the main content by replacing the processed block text with a modified version
+    modified_block_text = original_block_text.replace("# [x] extract", "# [v] extract", 1)
+    return updated_content.replace(original_block_text, modified_block_text, 1)
 
 def extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
     print(f"Starting extraction from '{document_path}'")
     block_extraction_counter = 0
 
-    with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
-        content = file.read()
+    try:
+        with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
+            content = file.read()
+    except FileNotFoundError:
+        print(f"Error: File not found at '{document_path}'. Skipping extraction.")
+        return
 
     cwd = os.getcwd()
     if relative_to_ara_root:
@@ -29,71 +98,27 @@ def extract_responses(document_path, relative_to_ara_root=False, force=False, wr
         navigator.navigate_to_target()
         os.chdir('..')
 
-    code_blocks_found = extract_code_blocks_md(content)
     updated_content = content
 
-    for block in code_blocks_found:
-        block_lines = block.split('\n')
+    while True:
+        md = MarkdownIt()
+        tokens = md.parse(updated_content)
 
-        if "# [x] extract" not in block_lines[0]:
-            continue
-        print("Block found and processed.")
-
-        block_lines = block_lines[1:]
-
-        file_path_search = re.search(r"# filename: (.+)", block_lines[0])
-
-        if file_path_search:
-            file_path = file_path_search.group(1).strip()
-            print(f"Filename extracted: {file_path}")
-
-            block_lines = block_lines[1:]  # Remove first line again after removing filename line
-            block = '\n'.join(block_lines)
-
-            handle_existing_file(file_path, block, force, write)
-            block_extraction_counter += 1
-
-            # Update the markdown content
-            updated_content = update_markdown(content, block, file_path)
-        else:
-            # Extract artefact
-            artefact_class = None
-            for line in block_lines[:2]:
-                words = line.strip().split(' ')
-                if not words:
-                    continue
-                first_word = words[0]
-                if first_word not in title_prefix_to_artefact_class:
-                    continue
-                artefact_class = title_prefix_to_artefact_class[first_word]
-            if not artefact_class:
-                print("No filename found, skipping this block.")
-                continue
-            artefact = artefact_class.deserialize('\n'.join(block_lines))
-            serialized_artefact = artefact.serialize()
-
-            original_directory = os.getcwd()
-            directory_navigator = DirectoryNavigator()
-            directory_navigator.navigate_to_target()
-
-            artefact_path = artefact.file_path
-            directory = os.path.dirname(artefact_path)
-            os.makedirs(directory, exist_ok=True)
-            handle_existing_file(artefact_path, serialized_artefact, force, write)
+        token_to_process = _find_extract_token(tokens)
+        if not token_to_process:
+            break  # No more blocks to process
 
-            os.chdir(original_directory)
+        block_extraction_counter += 1
+        print("Block found and processed.")
 
-            # TODO: make update_markdown work block by block instead of updating the whole document at once
-            block_extraction_counter += 1
-            updated_content = update_markdown(content, block, None)
+        updated_content = _process_extraction_block(token_to_process, updated_content, force, write)
 
     os.chdir(cwd)
-    # Save the updated markdown content
     with open(document_path, 'w', encoding='utf-8') as file:
         file.write(updated_content)
 
-    print(f"End of extraction. Found {block_extraction_counter} blocks.")
-
+    if block_extraction_counter > 0:
+        print(f"End of extraction. Found and processed {block_extraction_counter} blocks in '{os.path.basename(document_path)}'.")
 
 def modify_and_save_file(response, file_path):
     print(f"Debug: Modifying and saving file {file_path}")
@@ -119,11 +144,9 @@ def modify_and_save_file(response, file_path):
     except json.JSONDecodeError as ex:
         print(f"ERROR: Failed to decode JSON response: {ex}")
 
-
 def prompt_user_decision(prompt):
     return input(prompt)
 
-
 def determine_should_create(skip_query=False):
     if skip_query:
         return True
@@ -132,13 +155,14 @@ def determine_should_create(skip_query=False):
         return True
     return False
 
-
 def create_file_if_not_exist(filename, content, skip_query=False):
     try:
         if not os.path.exists(filename):
             if determine_should_create(skip_query):
                 # Ensure the directory exists
-                os.makedirs(os.path.dirname(filename), exist_ok=True)
+                dir_name = os.path.dirname(filename)
+                if dir_name:
+                    os.makedirs(dir_name, exist_ok=True)
 
                 with open(filename, 'w', encoding='utf-8') as file:
                     file.write(content)
@@ -150,7 +174,6 @@ def create_file_if_not_exist(filename, content, skip_query=False):
         print(f"Error: {e}")
         print(f"Failed to create file {filename} due to an OS error")
 
-
 def create_prompt_for_file_modification(content_str, filename):
     if not os.path.exists(filename):
         print(f"WARNING: {filename} for merge prompt creation does not exist.")
@@ -181,11 +204,15 @@ def create_prompt_for_file_modification(content_str, filename):
 
     return prompt_text
 
-
 def handle_existing_file(filename, block_content, skip_query=False, write=False):
     if not os.path.isfile(filename):
         print(f"File {filename} does not exist, attempting to create")
+        # Ensure directory exists before writing
+        directory = os.path.dirname(filename)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
         create_file_if_not_exist(filename, block_content, skip_query)
+
     elif write:
         print(f"File {filename} exists. Overwriting without LLM merge as requested.")
         try:
@@ -213,18 +240,9 @@ def handle_existing_file(filename, block_content, skip_query=False, write=False)
                 response += content
         modify_and_save_file(response, filename)
 
-
 def extract_and_save_prompt_results(classifier, param, write=False):
     sub_directory = Classifier.get_sub_directory(classifier)
     prompt_log_file = f"ara/{sub_directory}/{param}.data/{classifier}.prompt_log.md"
     print(f"Extract marked sections from: {prompt_log_file}")
 
-    extract_responses(prompt_log_file, write=write)
-
-
-def update_markdown(original_content, block_content, filename):
-    """
-    Update the markdown content by changing the extract block from "# [x] extract" to "# [v] extract"
-    """
-    updated_content = original_content.replace("# [x] extract", "# [v] extract")
-    return updated_content
+    extract_responses(prompt_log_file, write=write)

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
+    )