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

ara_cli/llm_utils.py

@@ -0,0 +1,58 @@
+from ara_cli.ara_config import ConfigManager
+from pydantic_ai import Agent
+
+FALLBACK_MODEL = "anthropic:claude-4-sonnet-20250514"
+
+
+def get_configured_conversion_llm_model() -> str:
+    """
+    Retrieves the configured conversion LLM model string, adapted for pydantic_ai.
+    Falls back to a default model if configuration is missing or invalid.
+    """
+    model_name = FALLBACK_MODEL
+    try:
+        config = ConfigManager.get_config()
+        conversion_llm_key = config.conversion_llm
+
+        if conversion_llm_key and conversion_llm_key in config.llm_config:
+            llm_config_item = config.llm_config[conversion_llm_key]
+            raw_model_name = llm_config_item.model
+
+            # Adapt LiteLLM model string to PydanticAI format
+            # LiteLLM: provider/model-name (e.g. openai/gpt-4o)
+            # PydanticAI: provider:model-name (e.g. openai:gpt-4o)
+            if "/" in raw_model_name and ":" not in raw_model_name:
+                parts = raw_model_name.split("/", 1)
+                if len(parts) == 2:
+                    model_name = f"{parts[0]}:{parts[1]}"
+                else:
+                    model_name = raw_model_name
+            else:
+                model_name = raw_model_name
+        else:
+            print(
+                f"Warning: Conversion LLM configuration issue. Using fallback model: {FALLBACK_MODEL}"
+            )
+    except Exception as e:
+        print(
+            f"Warning: Error resolving LLM config ({e}). Using fallback model: {FALLBACK_MODEL}"
+        )
+        model_name = FALLBACK_MODEL
+
+    return model_name
+
+
+def create_pydantic_ai_agent(
+    output_type, model_name: str = None, instrument: bool = True
+) -> Agent:
+    """
+    Creates a pydantic_ai Agent with the specified or configured model.
+    """
+    if not model_name:
+        model_name = get_configured_conversion_llm_model()
+
+    return Agent(
+        model=model_name,
+        output_type=output_type,
+        instrument=instrument,
+    )

ara_cli/prompt_chat.py

@@ -6,9 +6,18 @@ from ara_cli.update_config_prompt import update_artefact_config_prompt_files
 from ara_cli.output_suppressor import suppress_stdout
 
 
-def initialize_prompt_chat_mode(classifier, param, chat_name, reset=None, output_mode=False, append_strings=[], restricted=False):
+def initialize_prompt_chat_mode(
+    classifier,
+    param,
+    chat_name,
+    reset=None,
+    output_mode=False,
+    append_strings=[],
+    restricted=False,
+):
     sub_directory = Classifier.get_sub_directory(classifier)
-    artefact_data_path = os.path.join("ara", sub_directory, f"{param}.data") # f"ara/{sub_directory}/{parameter}.data"
+    # f"ara/{sub_directory}/{parameter}.data"
+    artefact_data_path = os.path.join("ara", sub_directory, f"{param}.data")
 
     if chat_name is None:
         chat_name = classifier
@@ -17,11 +26,18 @@ def initialize_prompt_chat_mode(classifier, param, chat_name, reset=None, output
         update_artefact_config_prompt_files(classifier, param, automatic_update=True)
 
     classifier_chat_file = os.path.join(artefact_data_path, f"{chat_name}")
-    start_chat_session(classifier_chat_file, reset, output_mode, append_strings, restricted)
+    start_chat_session(
+        classifier_chat_file, reset, output_mode, append_strings, restricted
+    )
+
 
 def start_chat_session(chat_file, reset, output_mode, append_strings, restricted):
     with suppress_stdout(suppress=output_mode):
-        chat = Chat(chat_file, reset=reset) if not restricted else Chat(chat_file, reset=reset, enable_commands=whitelisted_commands)
+        chat = (
+            Chat(chat_file, reset=reset)
+            if not restricted
+            else Chat(chat_file, reset=reset, enable_commands=whitelisted_commands)
+        )
     if append_strings:
         chat.append_strings(append_strings)
     if output_mode:

ara_cli/prompt_extractor.py

@@ -9,90 +9,208 @@ 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):
-    md = MarkdownIt()
-    tokens = md.parse(markdown_text)
-    code_blocks = [token.content for token in tokens if token.type == 'fence']
-    return code_blocks
+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 extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
-    print(f"Starting extraction from '{document_path}'")
-    block_extraction_counter = 0
+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)
 
-    with open(document_path, 'r', encoding='utf-8', errors='replace') as file:
-        content = file.read()
 
-    cwd = os.getcwd()
-    if relative_to_ara_root:
-        navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
-        os.chdir('..')
+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()
 
-    code_blocks_found = extract_code_blocks_md(content)
-    updated_content = content
+    original_directory = os.getcwd()
+    directory_navigator = DirectoryNavigator()
+    directory_navigator.navigate_to_target()
 
-    for block in code_blocks_found:
-        block_lines = block.split('\n')
+    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)
 
-        if "# [x] extract" not in block_lines[0]:
-            continue
-        print("Block found and processed.")
-
-        block_lines = block_lines[1:]
+    os.chdir(original_directory)
 
-        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}")
+def _perform_extraction_for_block(source_lines, block_start, block_end, force, write):
+    """Helper function to process a single, identified block."""
+    original_block_text = '\n'.join(source_lines[block_start:block_end + 1])
+    block_content_lines = source_lines[block_start + 1:block_end]
+    block_content = '\n'.join(block_content_lines)
 
-            block_lines = block_lines[1:]  # Remove first line again after removing filename line
-            block = '\n'.join(block_lines)
+    block_lines = block_content.split('\n')
+    content_lines_after_extract = block_lines[1:]
 
-            handle_existing_file(file_path, block, force, write)
-            block_extraction_counter += 1
+    file_path = _extract_file_path(content_lines_after_extract)
 
-            # Update the markdown content
-            updated_content = update_markdown(content, block, file_path)
+    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:
-            # 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.")
+            print(
+                "No filename or valid artefact found, skipping processing for this block.")
+            return None, None
+
+    modified_block_text = original_block_text.replace(
+        "# [x] extract", "# [v] extract", 1)
+    return original_block_text, modified_block_text
+
+
+class FenceDetector:
+    """Helper class to detect and match fence blocks."""
+
+    def __init__(self, source_lines):
+        self.source_lines = source_lines
+
+    def is_extract_fence(self, line_num):
+        """Check if line is a fence with extract marker."""
+        line = self.source_lines[line_num]
+        stripped_line = line.strip()
+
+        is_fence = stripped_line.startswith(
+            '```') or stripped_line.startswith('~~~')
+        if not is_fence:
+            return False
+
+        if not (line_num + 1 < len(self.source_lines)):
+            return False
+
+        return self.source_lines[line_num + 1].strip().startswith("# [x] extract")
+
+    def find_matching_fence_end(self, start_line):
+        """Find the matching end fence for a given start fence."""
+        fence_line = self.source_lines[start_line]
+        indentation = len(fence_line) - len(fence_line.lstrip())
+        stripped_fence_line = fence_line.strip()
+        fence_char = stripped_fence_line[0]
+        fence_length = len(stripped_fence_line) - \
+            len(stripped_fence_line.lstrip(fence_char))
+
+        for i in range(start_line + 1, len(self.source_lines)):
+            scan_line = self.source_lines[i]
+            stripped_scan_line = scan_line.strip()
+
+            if not stripped_scan_line or stripped_scan_line[0] != fence_char:
                 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()
+            if not all(c == fence_char for c in stripped_scan_line):
+                continue
 
-            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)
+            candidate_indentation = len(scan_line) - len(scan_line.lstrip())
+            candidate_length = len(stripped_scan_line)
+
+            if candidate_length == fence_length and candidate_indentation == indentation:
+                return i
+
+        return -1
+
+
+def _process_document_blocks(source_lines, force, write):
+    """Process all extract blocks in the document."""
+    fence_detector = FenceDetector(source_lines)
+    replacements = []
+    line_num = 0
+
+    while line_num < len(source_lines):
+        if not fence_detector.is_extract_fence(line_num):
+            line_num += 1
+            continue
+
+        block_start_line = line_num
+        block_end_line = fence_detector.find_matching_fence_end(
+            block_start_line)
+
+        if block_end_line != -1:
+            print(
+                f"Block found and processed starting on line {block_start_line + 1}.")
+            original, modified = _perform_extraction_for_block(
+                source_lines, block_start_line, block_end_line, force, write
+            )
+            if original and modified:
+                replacements.append((original, modified))
+            line_num = block_end_line + 1
+        else:
+            line_num += 1
+
+    return replacements
 
-            os.chdir(original_directory)
 
-            # 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)
+def _apply_replacements(content, replacements):
+    """Apply all replacements to the content."""
+    updated_content = content
+    for original, modified in replacements:
+        updated_content = updated_content.replace(original, modified, 1)
+    return updated_content
+
+
+def _setup_working_directory(relative_to_ara_root):
+    """Setup working directory and return original cwd."""
+    cwd = os.getcwd()
+    if relative_to_ara_root:
+        navigator = DirectoryNavigator()
+        navigator.navigate_to_target()
+        os.chdir('..')
+    return cwd
+
+
+def extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
+    print(f"Starting extraction from '{document_path}'", flush=True)
+
+    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 = _setup_working_directory(relative_to_ara_root)
+
+    source_lines = content.split('\n')
+    replacements = _process_document_blocks(source_lines, force, write)
+
+    updated_content = _apply_replacements(content, replacements)
 
     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 replacements:
+        print(
+            f"End of extraction. Found and processed {len(replacements)} blocks in '{os.path.basename(document_path)}'.")
 
 
 def modify_and_save_file(response, file_path):
@@ -107,7 +225,8 @@ def modify_and_save_file(response, file_path):
         """)
 
         if filename_from_response != file_path:
-            user_decision = prompt_user_decision("Filename does not match, overwrite? (y/n): ")
+            user_decision = prompt_user_decision(
+                "Filename does not match, overwrite? (y/n): ")
             if user_decision.lower() not in ['y', 'yes']:
                 print("Debug: User chose not to overwrite")
                 print("Skipping block.")
@@ -126,8 +245,11 @@ def prompt_user_decision(prompt):
 
 def determine_should_create(skip_query=False):
     if skip_query:
+        print("[DEBUG] skip_query is True, allowing creation.", flush=True)
         return True
-    user_decision = prompt_user_decision("File does not exist. Create? (y/n): ")
+    print(f"[DEBUG] About to prompt for file creation: File does not exist. Create? (y/n): ", flush=True)
+    user_decision = prompt_user_decision(
+        "File does not exist. Create? (y/n): ")
     if user_decision.lower() in ['y', 'yes']:
         return True
     return False
@@ -138,7 +260,9 @@ def create_file_if_not_exist(filename, content, skip_query=False):
         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)
@@ -156,8 +280,8 @@ def create_prompt_for_file_modification(content_str, filename):
         print(f"WARNING: {filename} for merge prompt creation does not exist.")
         return
 
-    content_of_existing_file = json.dumps(get_file_content(filename))
-    content = json.dumps(content_str)
+    content_of_existing_file = get_file_content(filename)
+    content = content_str
 
     prompt_text = f"""
     * given this new_content: 
@@ -185,9 +309,15 @@ def create_prompt_for_file_modification(content_str, filename):
 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.")
+        print(
+            f"File {filename} exists. Overwriting without LLM merge as requested.")
         try:
             directory = os.path.dirname(filename)
             if directory:
@@ -200,7 +330,8 @@ def handle_existing_file(filename, block_content, skip_query=False, write=False)
             print(f"Failed to overwrite file {filename} due to an OS error")
     else:
         print(f"File {filename} exists, creating modification prompt")
-        prompt_text = create_prompt_for_file_modification(block_content, filename)
+        prompt_text = create_prompt_for_file_modification(
+            block_content, filename)
         if prompt_text is None:
             return
 
@@ -220,11 +351,3 @@ def extract_and_save_prompt_results(classifier, param, write=False):
     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