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

ara_cli/__main__.py

@@ -1,5 +1,6 @@
 import typer
 import sys
+import os
 from typing import Optional
 from os import getenv
 from ara_cli.error_handler import AraError
@@ -44,6 +45,113 @@ def configure_debug_mode(debug: bool, env_debug_mode: bool):
         error_handler.debug_mode = True
 
 
+def find_ara_directory_root():
+    """Find the root ara directory by traversing up the directory tree."""
+    current_dir = os.getcwd()
+    
+    # Check if we're already inside an ara directory structure
+    path_parts = current_dir.split(os.sep)
+    
+    # Look for 'ara' in the path parts
+    if 'ara' in path_parts:
+        ara_index = path_parts.index('ara')
+        # Reconstruct path up to and including 'ara'
+        ara_root_parts = path_parts[:ara_index + 1]
+        potential_ara_root = os.sep.join(ara_root_parts)
+        if os.path.exists(potential_ara_root) and os.path.isdir(potential_ara_root):
+            return potential_ara_root
+    
+    # If not inside ara directory, check current directory and parents
+    check_dir = current_dir
+    while check_dir != os.path.dirname(check_dir):  # Stop at filesystem root
+        ara_path = os.path.join(check_dir, 'ara')
+        if os.path.exists(ara_path) and os.path.isdir(ara_path):
+            return ara_path
+        check_dir = os.path.dirname(check_dir)
+    
+    return None
+
+
+def check_ara_directory_exists():
+    """Check if ara directory exists or if we're inside ara directory tree."""
+    return find_ara_directory_root() is not None
+
+
+def prompt_create_ara_directory():
+    """Prompt user to create ara directory and create it if confirmed."""
+    # Print the prompt message
+    print("No 'ara' directory found. Create one in the current directory? (Y/n)", end=" ", flush=True)
+    
+    # Read user input
+    try:
+        response = input().strip()
+    except (EOFError, KeyboardInterrupt):
+        typer.echo("\nOperation cancelled.")
+        raise typer.Exit(1)
+    
+    if response.lower() in ('y', 'yes', ''):
+        current_dir = os.getcwd()
+        ara_path = os.path.join(current_dir, 'ara')
+        
+        # Create ara directory structure
+        subdirectories = [
+            'businessgoals',
+            'capabilities', 
+            'epics',
+            'examples',
+            'features',
+            'keyfeatures',
+            'tasks',
+            'userstories',
+            'vision'
+        ]
+        
+        try:
+            # Create main ara directory
+            os.makedirs(ara_path, exist_ok=True)
+            
+            # Create subdirectories for artefact types
+            for subdir in subdirectories:
+                os.makedirs(os.path.join(ara_path, subdir), exist_ok=True)
+            
+            # Create .araconfig directory
+            araconfig_path = os.path.join(ara_path, '.araconfig')
+            os.makedirs(araconfig_path, exist_ok=True)
+            
+            # Create default ara_config.json using ConfigManager
+            from ara_cli.ara_config import ConfigManager, ARAconfig
+            config_file_path = os.path.join(araconfig_path, 'ara_config.json')
+            
+            # Reset ConfigManager to ensure clean state
+            ConfigManager.reset()
+            
+            # Create default config and save it
+            default_config = ARAconfig()
+            from ara_cli.ara_config import save_data
+            save_data(config_file_path, default_config)
+            
+            typer.echo(f"Created ara directory structure at {ara_path}")
+            typer.echo(f"Created default configuration at {config_file_path}")
+            return True
+            
+        except OSError as e:
+            typer.echo(f"Error creating ara directory: {e}", err=True)
+            raise typer.Exit(1)
+        except Exception as e:
+            typer.echo(f"Error creating configuration file: {e}", err=True)
+            raise typer.Exit(1)
+    else:
+        typer.echo("Ara directory creation cancelled.")
+        raise typer.Exit(0)
+
+
+def requires_ara_directory():
+    """Check if ara directory exists and prompt to create if not."""
+    if not check_ara_directory_exists():
+        return prompt_create_ara_directory()
+    return True
+
+
 def create_app():
     app = typer.Typer(
         help="""The ara cli terminal tool is a management tool for classified ara artefacts.
@@ -124,6 +232,17 @@ ara chat examples:
         if ctx.invoked_subcommand is None:
             ctx.get_help()
             ctx.exit()
+        
+        # Check for ara directory before executing any command
+        # Skip check for commands that don't require ara directory
+        commands_requiring_ara = {
+            'create', 'delete', 'rename', 'list', 'list-tags', 'prompt', 
+            'read', 'reconnect', 'read-status', 'read-user', 'set-status', 
+            'set-user', 'classifier-directory', 'scan', 'autofix'
+        }
+        
+        if ctx.invoked_subcommand in commands_requiring_ara:
+            requires_ara_directory()
 
     # Register all commands
     register_create_cli(app)
@@ -162,4 +281,4 @@ def cli():
 
 
 if __name__ == "__main__":
-    cli()
+    cli()

ara_cli/artefact_autofix.py

@@ -487,7 +487,7 @@ def _convert_to_scenario_outline(scenario_lines: list, placeholders: set, indent
 def _create_examples_table(placeholders: set, base_indentation: str) -> list:
     """Create the Examples table for the scenario outline."""
     examples_indentation = base_indentation + "    "
-    table_indentation = examples_indentation + "  "
+    table_indentation = examples_indentation + " "
     
     sorted_placeholders = sorted(placeholders)
     header = "| " + " | ".join(sorted_placeholders) + " |"
@@ -576,6 +576,42 @@ def fix_rule(
     return artefact.serialize()
 
 
+def fix_misplaced_content(file_path: str, artefact_text: str, **kwargs) -> str:
+    """
+    Deterministically fixes content like 'Rule:' or 'Estimate:' misplaced in the description.
+    """
+    lines = artefact_text.splitlines()
+
+    desc_start_idx = -1
+    for i, line in enumerate(lines):
+        if line.strip().startswith("Description:"):
+            desc_start_idx = i
+            break
+
+    if desc_start_idx == -1:
+        return artefact_text  # No description, nothing to fix.
+
+    pre_desc_lines = lines[:desc_start_idx]
+    desc_line = lines[desc_start_idx]
+    post_desc_lines = lines[desc_start_idx+1:]
+
+    misplaced_content = []
+    new_post_desc_lines = []
+
+    for line in post_desc_lines:
+        if line.strip().startswith("Rule:") or line.strip().startswith("Estimate:"):
+            misplaced_content.append(line)
+        else:
+            new_post_desc_lines.append(line)
+
+    if not misplaced_content:
+        return artefact_text
+
+    # Rebuild the file content
+    final_lines = pre_desc_lines + misplaced_content + [""] + [desc_line] + new_post_desc_lines
+    return "\n".join(final_lines)
+
+
 def should_skip_issue(deterministic_issue, deterministic, non_deterministic, file_path) -> bool:
     if not non_deterministic and not deterministic_issue:
         print(f"Skipping non-deterministic fix for {file_path} as per request.")
@@ -622,7 +658,7 @@ def apply_non_deterministic_fix(
             corrected_artefact = run_agent(prompt, artefact_class)
             corrected_text = corrected_artefact.serialize()
         except Exception as e:
-            print(f"   ❌ LLM agent failed to fix artefact at {file_path}: {e}")
+            print(f"    ❌ LLM agent failed to fix artefact at {file_path}: {e}")
             return None
     return corrected_text
 
@@ -651,7 +687,7 @@ def attempt_autofix_loop(
         print(
             f"Attempting to fix {file_path} (Attempt {attempt + 1}/{max_attempts})..."
         )
-        print(f"   Reason: {current_reason}")
+        print(f"    Reason: {current_reason}")
 
         artefact_text = read_artefact(file_path)
         if artefact_text is None:
@@ -683,13 +719,13 @@ def attempt_autofix_loop(
 
         if corrected_text is None or corrected_text.strip() == artefact_text.strip():
             print(
-                "   Fixing attempt did not alter the file. Stopping to prevent infinite loop."
+                "    Fixing attempt did not alter the file. Stopping to prevent infinite loop."
             )
             return False
 
         write_corrected_artefact(file_path, corrected_text)
 
-        print("   File modified. Re-classifying artefact information for next check...")
+        print("    File modified. Re-classifying artefact information for next check...")
         classified_artefact_info = populate_classified_artefact_info(classified_artefact_info, force=True)
 
     print(f"❌ Failed to fix {file_path} after {max_attempts} attempts.")
@@ -713,6 +749,8 @@ def apply_autofix(
         "Invalid Contribution Reference": fix_contribution,
         "Rule Mismatch": fix_rule,
         "Scenario Contains Placeholders": fix_scenario_placeholder_mismatch,
+        "Found 'Rule:' inside description": fix_misplaced_content,
+        "Found 'Estimate:' inside description": fix_misplaced_content,
     }
 
     artefact_type, artefact_class = determine_artefact_type_and_class(classifier)
@@ -731,4 +769,4 @@ def apply_autofix(
         deterministic=deterministic,
         non_deterministic=non_deterministic,
         classified_artefact_info=classified_artefact_info,
-    )
+    )

ara_cli/artefact_models/artefact_model.py

@@ -410,14 +410,26 @@ class Artefact(BaseModel, ABC):
         return contribution, lines
 
     @classmethod
-    def _deserialize_description(cls, lines) -> (Optional[str], List[str]):
+    def _deserialize_description(cls, lines: List[str]) -> (Optional[str], List[str]):
         description_start = cls._description_starts_with()
+        start_index = -1
         for i, line in enumerate(lines):
             if line.startswith(description_start):
-                description = line[len(description_start):].strip()
-                del lines[i]
-                return description, lines
-        return None, lines
+                start_index = i
+                break
+
+        if start_index == -1:
+            return None, lines
+
+        first_line_content = lines[start_index][len(description_start):].strip()
+
+        description_lines = ([first_line_content] if first_line_content else []) + lines[start_index + 1:]
+
+        description = "\n".join(description_lines)
+
+        remaining_lines = lines[:start_index]
+
+        return (description if description else None), remaining_lines
 
     @classmethod
     def _parse_common_fields(cls, text: str) -> dict:
@@ -499,4 +511,4 @@ class Artefact(BaseModel, ABC):
             classifier=classifier,
             rule=rule
         )
-        self.contribution = contribution
+        self.contribution = contribution

ara_cli/artefact_models/epic_artefact_model.py

@@ -1,5 +1,5 @@
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Intent
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import List, Tuple, Optional
 
 
@@ -91,6 +91,15 @@ class EpicArtefact(Artefact):
         description="Rules the epic defines. It is recommended to create rules to clarify the desired outcome"
     )
 
+    @model_validator(mode='after')
+    def check_for_misplaced_rules(self) -> 'EpicArtefact':
+        if self.description:
+            desc_lines = self.description.split('\n')
+            for line in desc_lines:
+                if line.strip().startswith("Rule:"):
+                    raise ValueError("Found 'Rule:' inside description. Rules must be defined before the 'Description:' section.")
+        return self
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if v != ArtefactType.epic:
@@ -166,4 +175,4 @@ class EpicArtefact(Artefact):
             lines.append("")
         lines.append(description)
         lines.append("")
-        return "\n".join(lines)
+        return "\n".join(lines)

ara_cli/artefact_models/feature_artefact_model.py

@@ -301,6 +301,36 @@ class FeatureArtefact(Artefact):
                 f"FeatureArtefact must have artefact_type of '{ArtefactType.feature}', not '{v}'")
         return v
 
+    @classmethod
+    def _deserialize_description(cls, lines: List[str]) -> (Optional[str], List[str]):
+        description_start = cls._description_starts_with()
+        scenario_markers = ["Scenario:", "Scenario Outline:"]
+
+        start_index = -1
+        for i, line in enumerate(lines):
+            if line.startswith(description_start):
+                start_index = i
+                break
+
+        if start_index == -1:
+            return None, lines
+
+        end_index = len(lines)
+        for i in range(start_index + 1, len(lines)):
+            if any(lines[i].startswith(marker) for marker in scenario_markers):
+                end_index = i
+                break
+
+        first_line_content = lines[start_index][len(description_start):].strip()
+
+        description_lines_list = [first_line_content] if first_line_content else []
+        description_lines_list.extend(lines[start_index+1:end_index])
+
+        description = "\n".join(description_lines_list).strip() or None
+
+        remaining_lines = lines[:start_index] + lines[end_index:]
+
+        return description, remaining_lines
 
     @classmethod
     def _title_prefix(cls) -> str:
@@ -519,4 +549,4 @@ class FeatureArtefact(Artefact):
                     # or the placeholder is at the end of a line (e.g., "Then I see... __PLACEHOLDER__").
                     step = step.replace(key, value)
             rehydrated_steps.append(step)
-        return rehydrated_steps
+        return rehydrated_steps

ara_cli/artefact_models/userstory_artefact_model.py

@@ -1,5 +1,5 @@
 from ara_cli.artefact_models.artefact_model import Artefact, ArtefactType, Intent
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import List, Tuple
 
 
@@ -92,6 +92,18 @@ class UserstoryArtefact(Artefact):
         default_factory=list,
         description="Rules the userstory defines. It is recommended to create rules to clarify the desired outcome")
 
+    @model_validator(mode='after')
+    def check_for_misplaced_content(self) -> 'UserstoryArtefact':
+        if self.description:
+            desc_lines = self.description.split('\n')
+            for line in desc_lines:
+                stripped_line = line.strip()
+                if stripped_line.startswith("Rule:"):
+                    raise ValueError("Found 'Rule:' inside description. Rules must be defined before the 'Description:' section.")
+                if stripped_line.startswith("Estimate:"):
+                    raise ValueError("Found 'Estimate:' inside description. Estimate must be defined before the 'Description:' section.")
+        return self
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if v != ArtefactType.userstory:

ara_cli/chat.py

@@ -13,25 +13,6 @@ from ara_cli.file_loaders.binary_file_loader import BinaryFileLoader
 from ara_cli.file_loaders.text_file_loader import TextFileLoader
 
 
-extract_parser = argparse.ArgumentParser()
-extract_parser.add_argument(
-    "-f", "--force", action="store_true", help="Force extraction"
-)
-extract_parser.add_argument(
-    "-w",
-    "--write",
-    action="store_true",
-    help="Overwrite existing files without using LLM for merging.",
-)
-
-load_parser = argparse.ArgumentParser()
-load_parser.add_argument("file_name", nargs="?", default="", help="File to load")
-load_parser.add_argument(
-    "--load-images",
-    action="store_true",
-    help="Extract and describe images from documents",
-)
-
 extract_parser = argparse.ArgumentParser()
 extract_parser.add_argument(
     "-f", "--force", action="store_true", help="Force extraction"

ara_cli/file_loaders/text_file_loader.py

@@ -19,14 +19,14 @@ class TextFileLoader(FileLoader):
 
         if is_md_file and extract_images:
             reader = MarkdownReader(file_path)
-            file_content = reader.read(extract_images=True)
+            file_content = reader.read(extract_images=True).replace('\r\n', '\n')
         else:
             # Use charset-normalizer to detect encoding
             encoded_content = from_path(file_path).best()
             if not encoded_content:
                 print(f"Failed to detect encoding for {file_path}")
                 return False
-            file_content = str(encoded_content)
+            file_content = str(encoded_content).replace('\r\n', '\n')
 
         if block_delimiter:
             file_content = f"{block_delimiter}\n{file_content}\n{block_delimiter}"

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)