ara-cli 0.1.9.69__py3-none-any.whl → 0.1.10.8__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)