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

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_models/artefact_model.py

@@ -184,6 +184,10 @@ class Artefact(BaseModel, ABC):
         default=[],
         description="Optional list of tags (0-many)",
     )
+    author: Optional[str] = Field(
+        default="creator_unknown",
+        description="Author of the artefact, must be a single entry of the form 'creator_<someone>'."
+    )
     title: str = Field(
         ...,
         description="Descriptive Artefact title (mandatory)",
@@ -252,6 +256,17 @@ class Artefact(BaseModel, ABC):
                 raise ValueError(f"Tag '{tag}' has the form of a status tag. Set `status` field instead of passing it with other tags")
             if tag.startswith("user_"):
                 raise ValueError(f"Tag '{tag} has the form of a user tag. Set `users` field instead of passing it with other tags")
+            if tag.startswith("creator_"):
+                raise ValueError(f"Tag '{tag}' has the form of an author tag. Set `author` field instead of passing it with other tags")
+        return v
+
+    @field_validator('author')
+    def validate_author(cls, v):
+        if v:
+            if not v.startswith("creator_"):
+                raise ValueError(f"Author '{v}' must start with 'creator_'.")
+            if len(v) <= len("creator_"):
+                raise ValueError("Creator name cannot be empty in author tag.")
         return v
 
     @field_validator('title')
@@ -291,32 +306,81 @@ class Artefact(BaseModel, ABC):
         tag_line = lines[0]
         if not tag_line.startswith('@'):
             return {}, lines
+
         tags = tag_line.split()
+        tag_dict = cls._process_tags(tags)
+        return tag_dict, lines[1:]
+
+    @classmethod
+    def _process_tags(cls, tags) -> Dict[str, str]:
+        """Process a list of tags and return a dictionary with categorized tags."""
         status = None
         regular_tags = []
         users = []
-        status_list = ["@to-do", "@in-progress", "@review", "@done", "@closed"]
-        user_prefix = "@user_"
-        user_prefix_length = len(user_prefix)
-
+        author = None
+        
         for tag in tags:
-            if not tag.startswith('@'):
-                raise ValueError(f"Tag '{tag}' should start with '@' but started with '{tag[0]}'")
-            if tag in status_list and status is not None:
-                raise ValueError(f"Multiple status tags found: '@{status}' and '{tag}'")
-            if tag in status_list:
-                status = tag[1:]
-                continue
-            if tag.startswith("@user_") and len(tag) > user_prefix_length + 1:
-                users.append(tag[user_prefix_length:])
-                continue
-            regular_tags.append(tag[1:])
-        tag_dict = {
+            cls._validate_tag_format(tag)
+            
+            if cls._is_status_tag(tag):
+                status = cls._process_status_tag(tag, status)
+            elif cls._is_user_tag(tag):
+                users.append(cls._extract_user_from_tag(tag))
+            elif cls._is_author_tag(tag):
+                author = cls._process_author_tag(tag, author)
+            else:
+                regular_tags.append(tag[1:])
+        
+        return {
             "status": status,
             "users": users,
-            "tags": regular_tags
+            "tags": regular_tags,
+            "author": author
         }
-        return tag_dict, lines[1:]
+
+    @classmethod
+    def _validate_tag_format(cls, tag):
+        """Validate that tag starts with @."""
+        if not tag.startswith('@'):
+            raise ValueError(f"Tag '{tag}' should start with '@' but started with '{tag[0]}'")
+
+    @classmethod
+    def _is_status_tag(cls, tag) -> bool:
+        """Check if tag is a status tag."""
+        status_list = ["@to-do", "@in-progress", "@review", "@done", "@closed"]
+        return tag in status_list
+
+    @classmethod
+    def _process_status_tag(cls, tag, current_status):
+        """Process status tag and check for duplicates."""
+        if current_status is not None:
+            raise ValueError(f"Multiple status tags found: '@{current_status}' and '{tag}'")
+        return tag[1:]  # Remove @ prefix
+
+    @classmethod
+    def _is_user_tag(cls, tag) -> bool:
+        """Check if tag is a user tag."""
+        user_prefix = "@user_"
+        return tag.startswith(user_prefix) and len(tag) > len(user_prefix)
+
+    @classmethod
+    def _extract_user_from_tag(cls, tag) -> str:
+        """Extract username from user tag."""
+        user_prefix = "@user_"
+        return tag[len(user_prefix):]
+
+    @classmethod
+    def _is_author_tag(cls, tag) -> bool:
+        """Check if tag is an author tag."""
+        creator_prefix = "@creator_"
+        return tag.startswith(creator_prefix) and len(tag) > len(creator_prefix)
+
+    @classmethod
+    def _process_author_tag(cls, tag, current_author):
+        """Process author tag and check for duplicates."""
+        if current_author is not None:
+            raise ValueError(f"Multiple author tags found: '@{current_author}' and '@{tag[1:]}'")
+        return tag[1:] 
 
     @classmethod
     def _deserialize_title(cls, lines) -> (str, List[str]):
@@ -367,7 +431,7 @@ class Artefact(BaseModel, ABC):
         contribution, remaining_lines = cls._deserialize_contribution(remaining_lines)
         description, remaining_lines = cls._deserialize_description(remaining_lines)
 
-        return {
+        fields = {
             'artefact_type': cls._artefact_type(),
             'tags': tags.get('tags', []),
             'users': tags.get('users', []),
@@ -376,6 +440,9 @@ class Artefact(BaseModel, ABC):
             'contribution': contribution,
             'description': description,
         }
+        if tags.get("author"):
+            fields["author"] = tags.get("author")
+        return fields
 
     @classmethod
     def deserialize(cls, text: str) -> 'Artefact':
@@ -407,6 +474,8 @@ class Artefact(BaseModel, ABC):
             tags.append(f"@{self.status}")
         for user in self.users:
             tags.append(f"@user_{user}")
+        if self.author:
+            tags.append(f"@{self.author}")
         for tag in self.tags:
             tags.append(f"@{tag}")
         return ' '.join(tags)