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

ara_cli/ara_subcommands/delete.py

@@ -0,0 +1,22 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import delete_action
+
+
+def delete_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact to be deleted"),
+    parameter: str = ArtefactNameArgument("Filename of artefact"),
+    force: bool = typer.Option(False, "-f", "--force", help="ignore nonexistent files and arguments, never prompt")
+):
+    """Delete an artefact file including its data directory."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        force=force
+    )
+    delete_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Delete an artefact file including its data directory"
+    parent.command(name="delete", help=help_text)(delete_main)

ara_cli/ara_subcommands/extract.py

@@ -0,0 +1,22 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import extract_action
+
+
+def extract_main(
+    filename: str = typer.Argument(help="Input file to extract from"),
+    force: bool = typer.Option(False, "-f", "--force", help="Answer queries with yes when extracting"),
+    write: bool = typer.Option(False, "-w", "--write", help="Overwrite existing files without using LLM for merging")
+):
+    """Extract blocks of marked content from a given file."""
+    args = MockArgs(
+        filename=filename,
+        force=force,
+        write=write
+    )
+    extract_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Extract blocks of marked content from a given file"
+    parent.command(name="extract", help=help_text)(extract_main)

ara_cli/ara_subcommands/fetch_templates.py

@@ -0,0 +1,14 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import fetch_templates_action
+
+
+def fetch_templates_main():
+    """Fetches templates and stores them in .araconfig."""
+    args = MockArgs()
+    fetch_templates_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Fetches templates and stores them in .araconfig"
+    parent.command(name="fetch-templates", help=help_text)(fetch_templates_main)

ara_cli/ara_subcommands/list.py

@@ -0,0 +1,65 @@
+import typer
+from ara_cli.error_handler import AraError
+from typing import Optional, List, Tuple
+from .common import MockArgs
+from ara_cli.ara_command_action import list_action
+
+
+def _validate_extension_options(include_extension: Optional[List[str]], exclude_extension: Optional[List[str]]) -> None:
+    """Validate that include and exclude extension options are mutually exclusive."""
+    if include_extension and exclude_extension:
+        raise AraError("--include-extension/-i and --exclude-extension/-e are mutually exclusive")
+
+
+def _validate_exclusive_options(branch: Optional[Tuple[str, str]], 
+                               children: Optional[Tuple[str, str]], 
+                               data: Optional[Tuple[str, str]]) -> None:
+    """Validate that branch, children, and data options are mutually exclusive."""
+    exclusive_options = [branch, children, data]
+    non_none_options = [opt for opt in exclusive_options if opt is not None]
+    if len(non_none_options) > 1:
+        raise AraError("--branch, --children, and --data are mutually exclusive")
+
+
+def list_main(
+    ctx: typer.Context,
+    include_content: Optional[List[str]] = typer.Option(None, "-I", "--include-content", help="filter for files which include given content"),
+    exclude_content: Optional[List[str]] = typer.Option(None, "-E", "--exclude-content", help="filter for files which do not include given content"),
+    include_tags: Optional[List[str]] = typer.Option(None, "--include-tags", help="filter for files which include given tags"),
+    exclude_tags: Optional[List[str]] = typer.Option(None, "--exclude-tags", help="filter for files which do not include given tags"),
+    include_extension: Optional[List[str]] = typer.Option(None, "-i", "--include-extension", "--include-classifier", help="list of extensions to include in listing"),
+    exclude_extension: Optional[List[str]] = typer.Option(None, "-e", "--exclude-extension", "--exclude-classifier", help="list of extensions to exclude from listing"),
+    branch: Optional[Tuple[str, str]] = typer.Option(None, "-b", "--branch", help="List artefacts in the parent chain (classifier artefact_name)"),
+    children: Optional[Tuple[str, str]] = typer.Option(None, "-c", "--children", help="List child artefacts (classifier artefact_name)"),
+    data: Optional[Tuple[str, str]] = typer.Option(None, "-d", "--data", help="List file in the data directory (classifier artefact_name)")
+):
+    """List files with optional tags.
+
+    Examples:
+        ara list --data feature my_feature --include-extension .md
+        ara list --include-extension .feature
+        ara list --children userstory my_story
+        ara list --branch userstory my_story --include-extension .businessgoal
+        ara list --include-content "example content" --include-extension .task
+    """
+    _validate_extension_options(include_extension, exclude_extension)
+    _validate_exclusive_options(branch, children, data)
+
+    args = MockArgs(
+        include_content=include_content,
+        exclude_content=exclude_content,
+        include_tags=include_tags,
+        exclude_tags=exclude_tags,
+        include_extension=include_extension,
+        exclude_extension=exclude_extension,
+        branch_args=tuple(branch) if branch else (None, None),
+        children_args=tuple(children) if children else (None, None),
+        data_args=tuple(data) if data else (None, None)
+    )
+
+    list_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "List files with optional tags"
+    parent.command(name="list", help=help_text)(list_main)

ara_cli/ara_subcommands/list_tags.py

@@ -0,0 +1,25 @@
+import typer
+from typing import Optional
+from .common import ClassifierEnum, MockArgs, ClassifierOption
+from ara_cli.ara_command_action import list_tags_action
+
+
+def list_tags_main(
+    json_output: bool = typer.Option(False, "-j", "--json/--no-json", help="Output tags as JSON"),
+    include_classifier: Optional[ClassifierEnum] = ClassifierOption("Show tags for an artefact type", "--include-classifier"),
+    exclude_classifier: Optional[ClassifierEnum] = ClassifierOption("Show tags for an artefact type", "--exclude-classifier"),
+    filtered_extra_column: bool = typer.Option(False, "--filtered-extra-column", help="Filter tags for extra column")
+):
+    """Show tags."""
+    args = MockArgs(
+        json=json_output,
+        include_classifier=include_classifier.value if include_classifier else None,
+        exclude_classifier=exclude_classifier.value if exclude_classifier else None,
+        filtered_extra_column=filtered_extra_column
+    )
+    list_tags_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Show tags"
+    parent.command(name="list-tags", help=help_text)(list_tags_main)

ara_cli/ara_subcommands/load.py

@@ -0,0 +1,48 @@
+import typer
+from .common import TemplateTypeEnum, MockArgs, TemplateTypeArgument, ChatNameArgument
+from ara_cli.ara_command_action import load_action
+
+
+def create_template_name_completer():
+    """Create a template name completer that can access the template_type context."""
+    def completer(incomplete: str) -> list[str]:
+        # This is a simplified version - in practice, you'd need to access
+        # the template_type from the current command context
+        from ara_cli.template_loader import TemplateLoader
+        import os
+
+        # For all template types since we can't easily get context in typer
+        all_templates = []
+        for template_type in ['rules', 'intention', 'commands', 'blueprint']:
+            try:
+                loader = TemplateLoader()
+                templates = loader.get_available_templates(template_type, os.getcwd())
+                all_templates.extend(templates)
+            except Exception:
+                continue
+
+        return [t for t in all_templates if t.startswith(incomplete)]
+    return completer
+
+
+def load_main(
+    chat_name: str = ChatNameArgument("Name of the chat file to load template into (without extension)"),
+    template_type: TemplateTypeEnum = TemplateTypeArgument("Type of template to load"),
+    template_name: str = typer.Argument(
+        "",
+        help="Name of the template to load. Supports wildcards and 'global/' prefix",
+        autocompletion=create_template_name_completer()
+    )
+):
+    """Load a template into a chat file."""
+    args = MockArgs(
+        chat_name=chat_name,
+        template_type=template_type.value,
+        template_name=template_name
+    )
+    load_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Load a template into a chat file"
+    parent.command(name="load", help=help_text)(load_main)

ara_cli/ara_subcommands/prompt.py

@@ -0,0 +1,136 @@
+import typer
+from typing import Optional, List
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument, ChatNameArgument
+from ara_cli.ara_command_action import prompt_action
+
+
+def prompt_init(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Initialize a macro prompt."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="init"
+    )
+    prompt_action(args)
+
+
+def prompt_load(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Load selected templates."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="load"
+    )
+    prompt_action(args)
+
+
+def prompt_send(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Send configured prompt to LLM."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="send"
+    )
+    prompt_action(args)
+
+
+def prompt_load_and_send(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Load templates and send prompt to LLM."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="load-and-send"
+    )
+    prompt_action(args)
+
+
+def prompt_extract(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory"),
+    write: bool = typer.Option(False, "-w", "--write", help="Overwrite existing files without using LLM for merging")
+):
+    """Extract LLM response and save to disk."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="extract",
+        write=write
+    )
+    prompt_action(args)
+
+
+def prompt_update(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Update artefact config prompt files."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="update"
+    )
+    prompt_action(args)
+
+
+def prompt_chat(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory"),
+    chat_name: Optional[str] = ChatNameArgument("Optional name for a specific chat", None),
+    reset: Optional[bool] = typer.Option(None, "-r", "--reset/--no-reset", help="Reset the chat file if it exists"),
+    output_mode: bool = typer.Option(False, "--out", help="Output the contents of the chat file instead of entering interactive chat mode"),
+    append: Optional[List[str]] = typer.Option(None, "--append", help="Append strings to the chat file"),
+    restricted: Optional[bool] = typer.Option(None, "--restricted/--no-restricted", help="Start with a limited set of commands")
+):
+    """Start chat mode for the artefact."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="chat",
+        chat_name=chat_name,
+        reset=reset,
+        output_mode=output_mode,
+        append=append,
+        restricted=restricted
+    )
+    prompt_action(args)
+
+
+def prompt_init_rag(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Name of artefact data directory")
+):
+    """Initialize RAG prompt."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        steps="init-rag"
+    )
+    prompt_action(args)
+
+
+def register(parent: typer.Typer):
+    prompt_app = typer.Typer(
+        help="Base command for prompt interaction mode",
+        add_completion=False  # Disable completion on subcommand
+    )
+    prompt_app.command("init")(prompt_init)
+    prompt_app.command("load")(prompt_load)
+    prompt_app.command("send")(prompt_send)
+    prompt_app.command("load-and-send")(prompt_load_and_send)
+    prompt_app.command("extract")(prompt_extract)
+    prompt_app.command("update")(prompt_update)
+    prompt_app.command("chat")(prompt_chat)
+    prompt_app.command("init-rag")(prompt_init_rag)
+    parent.add_typer(prompt_app, name="prompt")

ara_cli/ara_subcommands/read.py

@@ -0,0 +1,47 @@
+import typer
+from typing import Optional, List
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import read_action
+
+
+def read_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type", default=None),
+    parameter: str = ArtefactNameArgument("Filename of artefact", default=None),
+    include_content: Optional[List[str]] = typer.Option(None, "-I", "--include-content", help="filter for files which include given content"),
+    exclude_content: Optional[List[str]] = typer.Option(None, "-E", "--exclude-content", help="filter for files which do not include given content"),
+    include_tags: Optional[List[str]] = typer.Option(None, "--include-tags", help="filter for files which include given tags"),
+    exclude_tags: Optional[List[str]] = typer.Option(None, "--exclude-tags", help="filter for files which do not include given tags"),
+    include_extension: Optional[List[str]] = typer.Option(None, "-i", "--include-extension", "--include-classifier", help="list of extensions to include in listing"),
+    exclude_extension: Optional[List[str]] = typer.Option(None, "-e", "--exclude-extension", "--exclude-classifier", help="list of extensions to exclude from listing"),
+    branch: bool = typer.Option(False, "-b", "--branch", help="Output the contents of artefacts in the parent chain"),
+    children: bool = typer.Option(False, "-c", "--children", help="Output the contents of child artefacts")
+):
+    """Reads contents of artefacts."""
+    # Handle mutually exclusive options
+    if branch and children:
+        typer.echo("Error: --branch and --children are mutually exclusive", err=True)
+        raise typer.Exit(1)
+
+    read_mode = None
+    if branch:
+        read_mode = "branch"
+    elif children:
+        read_mode = "children"
+
+    args = MockArgs(
+        classifier=classifier.value if classifier else None,
+        parameter=parameter,
+        include_content=include_content,
+        exclude_content=exclude_content,
+        include_tags=include_tags,
+        exclude_tags=exclude_tags,
+        include_extension=include_extension,
+        exclude_extension=exclude_extension,
+        read_mode=read_mode
+    )
+    read_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Reads contents of artefacts"
+    parent.command(name="read", help=help_text)(read_main)

ara_cli/ara_subcommands/read_status.py

@@ -0,0 +1,20 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import read_status_action
+
+
+def read_status_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type"),
+    parameter: str = ArtefactNameArgument("Filename of artefact")
+):
+    """Read status of an artefact by checking its tags."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter
+    )
+    read_status_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Read status of an artefact by checking its tags"
+    parent.command(name="read-status", help=help_text)(read_status_main)

ara_cli/ara_subcommands/read_user.py

@@ -0,0 +1,20 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import read_user_action
+
+
+def read_user_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type"),
+    parameter: str = ArtefactNameArgument("Filename of artefact")
+):
+    """Read user of an artefact by checking its tags."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter
+    )
+    read_user_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Read user of an artefact by checking its tags"
+    parent.command(name="read-user", help=help_text)(read_user_main)

ara_cli/ara_subcommands/reconnect.py

@@ -0,0 +1,27 @@
+import typer
+from typing import Optional
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument, ParentNameArgument
+from ara_cli.ara_command_action import reconnect_action
+
+
+def reconnect_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type"),
+    parameter: str = ArtefactNameArgument("Filename of artefact"),
+    parent_classifier: ClassifierEnum = ClassifierArgument("Classifier of the parent artefact type"),
+    parent_name: str = ParentNameArgument("Filename of parent artefact"),
+    rule: Optional[str] = typer.Option(None, "-r", "--rule", help="Rule for connection")
+):
+    """Connect an artefact to a parent artefact."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        parent_classifier=parent_classifier.value,
+        parent_name=parent_name,
+        rule=rule
+    )
+    reconnect_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Connect an artefact to a parent artefact"
+    parent.command(name="reconnect", help=help_text)(reconnect_main)

ara_cli/ara_subcommands/rename.py

@@ -0,0 +1,22 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import rename_action
+
+
+def rename_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact"),
+    parameter: str = ArtefactNameArgument("Filename of artefact"),
+    aspect: str = typer.Argument(help="New artefact name and new data directory name")
+):
+    """Rename a classified artefact and its data directory."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        aspect=aspect
+    )
+    rename_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Rename a classified artefact and its data directory"
+    parent.command(name="rename", help=help_text)(rename_main)

ara_cli/ara_subcommands/scan.py

@@ -0,0 +1,14 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import scan_action
+
+
+def scan_main():
+    """Scan ARA tree for incompatible artefacts."""
+    args = MockArgs()
+    scan_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Scan ARA tree for incompatible artefacts"
+    parent.command(name="scan", help=help_text)(scan_main)

ara_cli/ara_subcommands/set_status.py

@@ -0,0 +1,22 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument, StatusArgument
+from ara_cli.ara_command_action import set_status_action
+
+
+def set_status_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type, typically 'task'"),
+    parameter: str = ArtefactNameArgument("Name of the task artefact"),
+    new_status: str = StatusArgument("New status to set for the task")
+):
+    """Set the status of a task."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        new_status=new_status
+    )
+    set_status_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Set the status of a task"
+    parent.command(name="set-status", help=help_text)(set_status_main)

ara_cli/ara_subcommands/set_user.py

@@ -0,0 +1,22 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument, ArtefactNameArgument
+from ara_cli.ara_command_action import set_user_action
+
+
+def set_user_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type, typically 'task'"),
+    parameter: str = ArtefactNameArgument("Name of the task artefact"),
+    new_user: str = typer.Argument(help="New user to assign to the task")
+):
+    """Set the user of a task."""
+    args = MockArgs(
+        classifier=classifier.value,
+        parameter=parameter,
+        new_user=new_user
+    )
+    set_user_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Set the user of a task"
+    parent.command(name="set-user", help=help_text)(set_user_main)

ara_cli/ara_subcommands/template.py

@@ -0,0 +1,16 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument
+from ara_cli.ara_command_action import template_action
+
+
+def template_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type")
+):
+    """Outputs a classified ara template in the terminal."""
+    args = MockArgs(classifier=classifier.value)
+    template_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Outputs a classified ara template in the terminal"
+    parent.command(name="template", help=help_text)(template_main)

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