ara-cli 0.1.9.69__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

tests/test_tag_extractor.py

@@ -8,10 +8,11 @@ from ara_cli.list_filter import ListFilter
 def artefact():
     """Fixture to create a mock artefact object."""
     class Artefact:
-        def __init__(self, tags, status, users, path="dummy.md", content=""):
+        def __init__(self, tags, status, users, author="creator_unknown", path="dummy.md", content=""):
             self.tags = tags
             self.status = status
             self.users = users
+            self.author = author
             self.path = path
             self.content = content
     return Artefact
@@ -21,33 +22,33 @@ def artefact():
     (
         False, False, None,
         {'artefacts': [
-            (['tag1', 'tag2'], 'in-progress', ['user1']),
-            (['tag3'], 'done', ['user2'])
+            (['tag1', 'tag2'], 'in-progress', ['user1'], "creator_unknown"),
+            (['tag3'], 'done', ['user2'], "creator_unknown")
         ]},
-        ['done', 'in-progress', 'tag1', 'tag2', 'tag3', 'user_user1', 'user_user2']
+        ['creator_unknown', 'done', 'in-progress', 'tag1', 'tag2', 'tag3', 'user_user1', 'user_user2']
     ),
     (
         False, True, None,
         {'artefacts': [
-            (['project_a', 'priority_high'], None, ['user1']),
-            (['feature_x'], 'done', ['user2'])
+            (['project_a', 'priority_high'], None, ['user1'], "creator_unknown"),
+            (['feature_x'], 'done', ['user2'], "creator_unknown")
         ]},
         ['project_a']
     ),
     (
-        False, False, ListFilter(include_tags=['@kritik']),
+        False, False, ListFilter(include_tags=['kritik']),
         {'artefacts': [
-            (['release', 'kritik'], 'review', ['dev1']),
-            (['bugfix'], 'to-do', ['dev2'])
+            (['release', 'kritik'], 'review', ['dev1'], "creator_unknown"),
+            (['bugfix'], 'to-do', ['dev2'], "creator_unknown")
         ]},
-        ['kritik', 'release', 'review', 'user_dev1']
+        ['creator_unknown', 'kritik', 'release', 'review', 'user_dev1']
     ),
     (
         True, False, None,
         {'artefacts': [
-            (['tag3'], 'status2', ['user3'])
+            (['tag3'], 'status2', ['user3'], "creator_unknown")
         ]},
-        ['status2', 'tag3', 'user_user3']
+        ['creator_unknown', 'status2', 'tag3', 'user_user3']
     ),
     (
         False, False, None,
@@ -80,4 +81,9 @@ def test_extract_tags(mock_directory_navigator, mock_artefact_reader, artefact,
 
     mock_artefact_reader.read_artefacts.assert_called_once()
 
-    assert sorted(result) == sorted(expected_tags)
+    # Convert dictionary result to flat list for comparison
+    actual_tags = []
+    for group in result.values():
+        actual_tags.extend(group)
+    
+    assert sorted(actual_tags) == sorted(expected_tags)

tests/test_template_loader.py

@@ -0,0 +1,192 @@
+import os
+import pytest
+from unittest.mock import MagicMock, patch, mock_open
+from ara_cli.template_loader import TemplateLoader
+
+
+@pytest.fixture
+def mock_chat_instance():
+    """Fixture for a mocked chat instance."""
+    mock = MagicMock()
+    mock.choose_file_to_load.return_value = "chosen_file.md"
+    mock.load_file.return_value = True
+    return mock
+
+
+@pytest.fixture
+def template_loader_cli():
+    """Fixture for a TemplateLoader in CLI mode."""
+    return TemplateLoader()
+
+
+@pytest.fixture
+def template_loader_chat(mock_chat_instance):
+    """Fixture for a TemplateLoader in chat mode."""
+    return TemplateLoader(chat_instance=mock_chat_instance)
+
+
+def test_init(mock_chat_instance):
+    """Test the constructor."""
+    loader_cli = TemplateLoader()
+    assert loader_cli.chat_instance is None
+
+    loader_chat = TemplateLoader(chat_instance=mock_chat_instance)
+    assert loader_chat.chat_instance == mock_chat_instance
+
+
+@pytest.mark.parametrize("template_name, default_pattern, expected_method_to_call", [
+    ("", "*.rules.md", "load_template_from_prompt_data"),
+    ("my_rule", "*.rules.md", "load_template_from_global_or_local"),
+])
+def test_load_template_routing(template_loader_cli, template_name, default_pattern, expected_method_to_call):
+    """Test that load_template calls the correct downstream method based on inputs."""
+    with patch.object(TemplateLoader, 'load_template_from_prompt_data') as mock_from_prompt, \
+         patch.object(TemplateLoader, 'load_template_from_global_or_local') as mock_from_global_local:
+
+        template_loader_cli.load_template(
+            template_name, "rules", "chat.md", default_pattern)
+
+        if expected_method_to_call == "load_template_from_prompt_data":
+            mock_from_prompt.assert_called_once()
+            mock_from_global_local.assert_not_called()
+        else:
+            mock_from_prompt.assert_not_called()
+            mock_from_global_local.assert_called_once()
+
+
+def test_load_template_no_name_no_pattern(template_loader_cli, capsys):
+    """Test load_template fails gracefully when no name or pattern is given."""
+    result = template_loader_cli.load_template("", "blueprint", "chat.md", None)
+    assert result is False
+    captured = capsys.readouterr()
+    assert "A template name is required for template type 'blueprint'" in captured.out
+
+
+@pytest.mark.parametrize("template_type, expected_plural", [
+    ("rules", "rules"),
+    ("commands", "commands"),
+    ("intention", "intentions"),
+    ("blueprint", "blueprints"),
+    ("custom", "customs"),
+])
+def test_get_plural_template_type(template_loader_cli, template_type, expected_plural):
+    """Test the pluralization of template types."""
+    assert template_loader_cli.get_plural_template_type(
+        template_type) == expected_plural
+
+
+@pytest.mark.parametrize("template_name, expected_method_to_call", [
+    ("global/my_rule", "_load_global_template"),
+    ("my_rule", "_load_local_template"),
+])
+def test_load_template_from_global_or_local_routing(template_loader_cli, template_name, expected_method_to_call):
+    """Test routing between global and local template loading."""
+    with patch.object(TemplateLoader, '_load_global_template') as mock_global, \
+         patch.object(TemplateLoader, '_load_local_template') as mock_local:
+
+        template_loader_cli.load_template_from_global_or_local(
+            template_name, "rules", "chat.md")
+
+        if expected_method_to_call == "_load_global_template":
+            mock_global.assert_called_once()
+            mock_local.assert_not_called()
+        else:
+            mock_global.assert_not_called()
+            mock_local.assert_called_once()
+
+
+@pytest.mark.parametrize("files, pattern, user_input, expected_return", [
+    (["one.md"], "*.md", "", "one.md"),
+    ([], "*.md", "", None),
+    (["a.md", "b.md"], "*", "1", "a.md"),
+    (["a.md", "b.md"], "*", "2", "b.md"),
+    (["a.md", "b.md"], "*", "3", None),
+    (["a.md", "b.md"], "*", "invalid", None),
+])
+def test_choose_file_for_cli(template_loader_cli, files, pattern, user_input, expected_return):
+    """Test the interactive file selection for the CLI."""
+    with patch('builtins.input', return_value=user_input):
+        result = template_loader_cli._choose_file_for_cli(files, pattern)
+        assert result == expected_return
+
+
+def test_load_file_to_chat_cli_context(tmp_path):
+    """Test writing template content to a chat file in a CLI context."""
+    chat_file = tmp_path / "chat.md"
+    chat_file.write_text("# ara prompt:\n")
+    template_file = tmp_path / "template.md"
+    template_content = "This is the template content."
+    template_file.write_text(template_content)
+
+    loader = TemplateLoader()
+    result = loader._load_file_to_chat(
+        str(template_file), "rules", str(chat_file))
+
+    assert result is True
+    final_content = chat_file.read_text()
+    expected_content = f"# ara prompt:\n\n{template_content}\n"
+    assert final_content == expected_content
+
+
+def test_load_file_to_chat_chat_context(template_loader_chat, mock_chat_instance):
+    """Test delegating file loading to the chat instance."""
+    result = template_loader_chat._load_file_to_chat(
+        "file.md", "rules", "chat.md")
+
+    assert result is True
+    mock_chat_instance.add_prompt_tag_if_needed.assert_called_once_with(
+        "chat.md")
+    mock_chat_instance.load_file.assert_called_once_with("file.md")
+
+
+def test_find_project_root(tmp_path):
+    """Test finding the project root directory."""
+    project_root = tmp_path / "project"
+    ara_dir = project_root / "ara"
+    nested_dir = project_root / "src" / "component"
+    ara_dir.mkdir(parents=True)
+    nested_dir.mkdir(parents=True)
+
+    no_ara_dir = tmp_path / "other"
+    no_ara_dir.mkdir()
+
+    loader = TemplateLoader()
+
+    # Test finding the root from a nested directory
+    assert loader._find_project_root(str(nested_dir)) == str(project_root)
+    # Test finding the root from the root itself
+    assert loader._find_project_root(str(project_root)) == str(project_root)
+    # Test not finding the root
+    assert loader._find_project_root(str(no_ara_dir)) is None
+
+
+@patch('ara_cli.template_loader.TemplatePathManager')
+@patch('ara_cli.template_loader.ConfigManager')
+def test_get_available_templates(MockConfigManager, MockTemplatePathManager, tmp_path):
+    """Test the discovery of global and local templates."""
+    # Setup mock paths and config
+    project_root = tmp_path / "project"
+    ara_dir = project_root / "ara"
+    araconfig_dir = project_root / ".araconfig"
+    custom_modules_dir = araconfig_dir / "custom-prompt-modules" / "rules"
+    global_modules_dir = tmp_path / "global_templates" / "prompt-modules" / "rules"
+
+    for d in [ara_dir, custom_modules_dir, global_modules_dir]:
+        d.mkdir(parents=True)
+
+    (custom_modules_dir / "local_rule.md").touch()
+    (global_modules_dir / "global_rule.md").touch()
+
+    mock_config = MagicMock()
+    mock_config.local_prompt_templates_dir = ".araconfig"
+    mock_config.custom_prompt_templates_subdir = "custom-prompt-modules"
+    MockConfigManager.get_config.return_value = mock_config
+    MockTemplatePathManager.get_template_base_path.return_value = str(
+        tmp_path / "global_templates")
+
+    loader = TemplateLoader()
+    templates = loader.get_available_templates(
+        "rules", context_path=str(project_root))
+
+    assert sorted(templates) == sorted(
+        ["global/global_rule.md", "local_rule.md"])

tests/test_template_manager.py

@@ -9,10 +9,11 @@ import os
 
 @pytest.fixture(autouse=True)
 def navigate_to_ara_directory():
-    navigator = DirectoryNavigator("ara")
-    original_directory = navigator.navigate_to_target()
-    yield
-    os.chdir(original_directory)
+    with patch('builtins.input', return_value='y'):
+        navigator = DirectoryNavigator("ara")
+        original_directory = navigator.navigate_to_target()
+        yield
+        os.chdir(original_directory)
 
 
 @pytest.mark.parametrize(

tests/test_update_config_prompt.py

@@ -34,13 +34,13 @@ mock_content_updated = """
 def test_read_file():
     with patch('builtins.open', mock_open(read_data="data")) as mocked_file:
         result = read_file('dummy_path')
-        mocked_file.assert_called_once_with('dummy_path', 'r')
+        mocked_file.assert_called_once_with('dummy_path', 'r', encoding='utf-8')
         assert result == "data"
 
 def test_write_file():
     with patch('builtins.open', mock_open()) as mocked_file:
         write_file('dummy_path', 'data')
-        mocked_file.assert_called_once_with('dummy_path', 'w')
+        mocked_file.assert_called_once_with('dummy_path', 'w', encoding='utf-8')
         mocked_file().write.assert_called_once_with('data')
 
 def test_find_checked_items():

ara_cli/ara_command_parser.py

@@ -1,327 +0,0 @@
-import argparse
-from ara_cli.classifier import Classifier
-from ara_cli.commandline_completer import ArtefactCompleter, ParentNameCompleter, StatusCompleter
-from ara_cli.template_manager import SpecificationBreakdownAspects
-
-
-classifiers = Classifier.ordered_classifiers()
-aspects = SpecificationBreakdownAspects.VALID_ASPECTS
-
-
-def create_parser(subparsers):
-    create_parser = subparsers.add_parser("create", help="Create a classified artefact with data directory")
-    create_parser.add_argument("classifier", choices=classifiers, help="Classifier that also serves as file extension for the artefact file to be created. Valid Classifiers are: businessgoal, capability, keyfeature, feature, epic, userstory, example, task")
-    create_parser.add_argument("parameter", help="Artefact name that serves as filename").completer = ArtefactCompleter()
-
-    option_parser = create_parser.add_subparsers(dest="option")
-
-    contribution_parser = option_parser.add_parser("contributes-to")
-    contribution_parser.add_argument("parent_classifier", choices=classifiers, help="Classifier of the parent")
-    contribution_parser.add_argument("parent_name",  help="Name of a parent artefact").completer = ParentNameCompleter()
-    contribution_parser.add_argument("-r", "--rule", dest="rule", action="store")
-
-    aspect_parser = option_parser.add_parser("aspect")
-    aspect_parser.add_argument("aspect", choices=aspects, help="Adds additional specification breakdown aspects in data directory.")
-
-
-def delete_parser(subparsers):
-    delete_parser = subparsers.add_parser("delete", help="Delete an artefact file including its data directory")
-    delete_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact to be deleted")
-    delete_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-    delete_parser.add_argument("-f", "--force", dest="force", action="store_true", help="ignore nonexistent files and arguments, never prompt")
-
-
-def rename_parser(subparsers):
-    rename_parser = subparsers.add_parser("rename", help="Rename a classified artefact and its data directory")
-    rename_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact")
-    rename_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-    rename_parser.add_argument("aspect", help="New artefact name and new data directory name")
-
-
-def add_filter_flags(parser):
-    parser.add_argument(
-        "-I",
-        "--include-content",
-        nargs="+",
-        default=None,
-        help="filter for files which include given content"
-    )
-    parser.add_argument(
-        "-E",
-        "--exclude-content",
-        nargs="+",
-        default=None,
-        help="filter for files which do not include given content"
-    )
-
-    parser.add_argument(
-        "--include-tags",
-        nargs="+",
-        default=None,
-        help="filter for files which include given tags"
-    )
-    parser.add_argument(
-        "--exclude-tags",
-        nargs="+",
-        default=None,
-        help="filter for files which do not include given tags"
-    )
-
-    extension_group = parser.add_mutually_exclusive_group()
-    extension_group.add_argument(
-        "-i",
-        "--include-extension",
-        "--include-classifier",
-        dest="include_extension",
-        nargs='+',
-        help='list of extensions to include in listing'
-    )
-    extension_group.add_argument(
-        "-e",
-        "--exclude-extension",
-        "--exclude-classifier",
-        dest="exclude_extension",
-        nargs='+',
-        help='list of extensions to exclude from listing'
-    )
-
-
-def list_parser(subparsers):
-    list_parser = subparsers.add_parser("list", help="List files with optional tags")
-    list_parser.add_argument("tags", nargs="*", help="Tags for listing files")
-
-    add_filter_flags(list_parser)
-
-    argument_group = list_parser.add_mutually_exclusive_group()
-    argument_group.add_argument(
-        "-b", "--branch",
-        dest="branch_args",
-        nargs=2,
-        metavar=("classifier", "artefact_name"),
-        help="List artefacts in the parent chain of the artefact with specified classifier and artefact_name"
-    )
-    argument_group.add_argument(
-        "-c", "--children",
-        dest="children_args",
-        nargs=2,
-        metavar=("classifier", "artefact_name"),
-        help="List child artefacts of the artefact with specified classifier and artefact_name"
-    )
-    argument_group.add_argument(
-        "-d", "--data",
-        dest="data_args",
-        nargs=2,
-        metavar=("classifier", "artefact_name"),
-        help="List file in the data directory of the artefact with specified classifier and artefact_name"
-    )
-
-    list_parser.set_defaults(
-        branch_args=(None, None),
-        children_args=(None, None),
-        data_args=(None, None)
-    )
-
-
-def list_tags_parser(subparsers):
-    tags_parser = subparsers.add_parser("list-tags", help="Show tags")
-    tags_parser.add_argument("--json", "-j", help="Output tags as JSON", action=argparse.BooleanOptionalAction)
-    tags_parser.add_argument("--include-classifier", choices=classifiers, help="Show tags for an artefact type")
-    tags_parser.add_argument("--exclude_classifier", choices=classifiers, help="Show tags for an artefact type")
-    tags_parser.add_argument("--filtered-extra-column", action="store_true", help="Filter tags for extra column") 
-
-
-def add_chat_arguments(chat_parser):
-    chat_parser.add_argument("chat_name", help="Optional name for a specific chat. Pass the .md file to continue an existing chat", nargs='?', default=None)
-
-    chat_parser.add_argument("-r", "--reset", dest="reset", action=argparse.BooleanOptionalAction, help="Reset the chat file if it exists")
-    chat_parser.set_defaults(reset=None)
-
-    chat_parser.add_argument("--out", dest="output_mode", action="store_true", help="Output the contents of the chat file instead of entering interactive chat mode")
-
-    chat_parser.add_argument("--append", nargs='*', default=None, help="Append strings to the chat file")
-
-    chat_parser.add_argument("--restricted", dest="restricted", action=argparse.BooleanOptionalAction, help="Start with a limited set of commands")
-
-
-def prompt_parser(subparsers):
-    prompt_parser = subparsers.add_parser("prompt", help="Base command for prompt interaction mode")
-
-    steps = ['init', 'load', 'send', 'load-and-send', 'extract', 'update', 'chat', 'init-rag']
-    steps_parser = prompt_parser.add_subparsers(dest='steps')
-    for step in steps:
-        step_parser = steps_parser.add_parser(step)
-        step_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact")
-        step_parser.add_argument("parameter", help="Name of artefact data directory for prompt creation and interaction").completer = ArtefactCompleter()
-        if step == 'chat':
-            add_chat_arguments(step_parser)
-
-
-def chat_parser(subparsers):
-    chat_parser = subparsers.add_parser("chat", help="Command line chatbot. Chat control with SEND/s | RERUN/r | QUIT/q")
-    add_chat_arguments(chat_parser)
-
-
-def template_parser(subparsers):
-    template_parser = subparsers.add_parser("template", help="Outputs a classified ara template in the terminal")
-    template_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-
-
-def fetch_templates_parser(subparsers):
-    subparsers.add_parser("fetch-templates", help="Fetches templates and stores them in .araconfig")
-
-
-def read_parser(subparsers):
-    read_parser = subparsers.add_parser("read", help="Reads contents of artefacts")
-    read_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-    read_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-
-    branch_group = read_parser.add_mutually_exclusive_group()
-    branch_group.add_argument("-b", "--branch", dest="read_mode", action="store_const", const="branch",
-                              help="Output the contents of artefacts in the parent chain")
-    branch_group.add_argument("-c", "--children", dest="read_mode", action="store_const", const="children",
-                              help="Output the contents of child artefacts")
-
-    read_parser.set_defaults(read_mode=None)
-
-
-def reconnect_parser(subparsers):
-    reconnect_parser = subparsers.add_parser("reconnect", help="Connect an artefact to a parent artefact")
-    reconnect_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-    reconnect_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-    reconnect_parser.add_argument("parent_classifier", choices=classifiers, help="Classifier of the parent artefact type")
-    reconnect_parser.add_argument("parent_name", help="Filename of parent artefact").completer = ParentNameCompleter()
-    reconnect_parser.add_argument("-r", "--rule", dest="rule", action="store")
-
-
-def read_status_parser(subparsers):
-    read_status_parser = subparsers.add_parser("read-status", help="Read status of an artefact by checking its tags")
-    read_status_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-    read_status_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-
-
-def read_user_parser(subparsers):
-    read_user_parser = subparsers.add_parser("read-user", help="Read user of an artefact by checking its tags")
-    read_user_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-    read_user_parser.add_argument("parameter", help="Filename of artefact").completer = ArtefactCompleter()
-
-
-def set_status_parser(subparsers):
-    set_status_parser = subparsers.add_parser("set-status", help="Set the status of a task")
-    set_status_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type, typically 'task'")
-    set_status_parser.add_argument("parameter", help="Name of the task artefact").completer = ArtefactCompleter()
-    set_status_parser.add_argument("new_status", help="New status to set for the task").completer = StatusCompleter()
-
-
-def set_user_parser(subparsers):
-    set_user_parser = subparsers.add_parser("set-user", help="Set the user of a task")
-    set_user_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type, typically 'task'")
-    set_user_parser.add_argument("parameter", help="Name of the task artefact").completer = ArtefactCompleter()
-    set_user_parser.add_argument("new_user", help="New user to assign to the task")
-
-
-def classifier_directory_parser(subparsers):
-    classifier_directory_parser = subparsers.add_parser("classifier-directory", help="Print the ara subdirectory for an artefact classifier")
-    classifier_directory_parser.add_argument("classifier", choices=classifiers, help="Classifier of the artefact type")
-
-
-def scan_parser(subparsers):
-    subparsers.add_parser("scan", help="Scan ARA tree for incompatible artefacts.")
-
-
-def autofix_parser(subparsers):
-    autofix_parser = subparsers.add_parser("autofix", help="Fix ARA tree with llm models for scanned artefacts with ara scan command.")
-    determinism_group = autofix_parser.add_mutually_exclusive_group()
-    determinism_group.add_argument("--deterministic", "-d", action="store_true", help="Run only deterministic fixes e.g Title-FileName Mismatch fix")
-    determinism_group.add_argument("--non-deterministic", "-nd", action="store_true", help="Run only non-deterministic fixes")
-
-
-class CustomHelpFormatter(argparse.HelpFormatter):
-    def format_help(self):
-        from sys import argv
-        # Get the default help message
-        help_message = super().format_help()
-
-        # Check if '-h' or '--help' is in the arguments
-        if '-h' in argv or '--help' in argv:
-            # Add custom examples or additional information
-            examples = (
-                "\nValid classified artefacts are: businessgoal, vision, capability, keyfeature, feature, epic, userstory, example, feature, task.\n"
-                "The default ara directory structure of classified artefact of the ara cli tool is:\n"
-                ".\n"
-                "└── ara\n"
-                "   ├── businessgoals\n"
-                "   ├── capabilities\n"
-                "   ├── epics\n"
-                "   ├── examples\n"
-                "   ├── features\n"
-                "   ├── keyfeatures\n"
-                "   ├── tasks\n"
-                "   ├── userstories\n"
-                "   └── vision\n"
-                "\n"
-                "\nara artefact handling examples:\n"
-                "  > create a new artefact for e.g. a feature:                                        ara create feature {feature_name}\n"
-                "  > create a new artefact for e.g. a feature that contributes to an userstory:       ara create feature {feature_name} contributes-to userstory {story_name}\n"
-                "  > read an artefact and return the content as terminal output, for eg. of a task:   ara read task {task_name}\n"
-                "  > read an artefact and its full chain of contributions to its parents and return\n"
-                "    the content as terminal output, for eg. of a task:                               ara read task {task_name} --branch\n"
-                "  > delete an artefact for e.g. feature:                                             ara delete feature {feature_name}\n"
-                "  > rename artefact and artefact data directory for e.g. a feature:                  ara rename feature {initial_feature_name} {new_feature_name}\n"
-                "  > create additional templates for a specific aspect (valid aspects are: customer,\n"
-                "    persona, concept, technology) related to an existing artefact like a feature:    ara create feature {feature_name} aspect {aspect_name}\n"
-                "  > list artefact data with .md file extension                                       ara list --data {classifier} {artefact_name} --include-extension .md\n"
-                "  > list artefact data with .md and .json file extensions                            ara list --data {classifier} {artefact_name} --include-extension .md .json\n"
-                "  > list everything but userstories                                                  ara list --exclude-extension .userstory\n"
-                "  > list all existing features:                                                      ara list --include-extension .feature\n"
-                "  > list all child artefacts contributing value to a parent artefact:                ara list --include-content \"Contributes to {name_of_parent_artefact} {ara classifier_of_parent_artefact}\"\n"
-                "  > list tasks which contain 'example content'                                       ara list --include-extension .task --include-content \"example content\"\n"
-                "  > list children artefacts of a userstory                                           ara list --children userstory {name_of_userstory}\n"
-                "  > list parent artefacts of a userstory                                             ara list --branch userstory {name_of_userstory}\n"
-                "  > list parent businessgoal artefact of a userstory                                 ara list --branch userstory {name_of_userstory} --include-extension .businessgoal\n"
-                "  > print any artefact template for e.g. a feature file template in the terminal:    ara template feature\n"
-                "\n"
-                " \nara prompt templates examples:\n"
-                " > get and copy all prompt templates (blueprints, rules, intentions, commands\n"
-                "   in the ara/.araconfig/global-prompt-modules directory:                            ara fetch-templates\n"
-                "\n"
-                " \nara chat examples:\n"
-                "  > chat with ara and save the default chat.md file in the working directory:        ara chat\n"
-                "  > chat with ara and save the default task_chat.md file in the task.data directory: ara prompt chat task {task_name}\n"
-                "\n"
-                "  > initialize a macro prompt for a task:                                            ara prompt init task {task_name}\n"
-                "  > load selected templates in config_prompt_templates.md for the task {task_name}:  ara prompt load task {task_name}\n"
-                "  > create and send configured prompt of the task {task_name} to the configured LLM: ara prompt send task {task_name}\n"
-                "  > extract the selected LLM response in task.exploration.md and save to disk:       ara prompt extract task {task_name}\n"
-
-            )
-            # Combine the default help message with the examples
-            return help_message + examples
-
-        return help_message
-
-
-def action_parser():
-    # Use the CustomHelpFormatter here
-    parser = argparse.ArgumentParser(description="The ara cli terminal tool is a management tool for classified ara artefacts.", formatter_class=CustomHelpFormatter)
-
-    subparsers = parser.add_subparsers(dest="action", help="Action to perform")
-    create_parser(subparsers)
-    delete_parser(subparsers)
-    rename_parser(subparsers)
-    list_parser(subparsers)
-    list_tags_parser(subparsers)
-    prompt_parser(subparsers)
-    chat_parser(subparsers)
-    template_parser(subparsers)
-    fetch_templates_parser(subparsers)
-    read_parser(subparsers)
-    reconnect_parser(subparsers)
-    read_status_parser(subparsers)
-    read_user_parser(subparsers)
-    set_status_parser(subparsers)
-    set_user_parser(subparsers)
-    classifier_directory_parser(subparsers)
-    scan_parser(subparsers)
-    autofix_parser(subparsers)
-
-    return parser

ara_cli/templates/prompt-modules/blueprints/complete_pytest_unittest.blueprint.md

@@ -1,27 +0,0 @@
-# Usage: 
-# necessary input and adaption: 
-# replace text snippets in <> with specific context
-# ...
-# expected output: 
-# ...
-Do not use usage information as prompt instructions
-
-
-Given source code
-```python
-<source code for context, skip irrelevant for current task>
-```
-
-Given existing unit tests
-```python
-<existing unit tests>
-```
-
-Given pytest is available
-
-Modify and/or create unit tests so this is fully covered:
-```python
-<snippet you want to cover in the next step>
-```
-
-Give me only what is relevant to testing this snippet. Use parametrization where applicable. Mock all dependencies of tested code.