ara-cli 0.1.10.0__tar.gz → 0.1.10.1__tar.gz

{ara_cli-0.1.10.0 → ara_cli-0.1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.10.0
+Version: 0.1.10.1
 Summary: Powerful, open source command-line tool for managing, structuring and automating software development artifacts in line with Business-Driven Development (BDD) and AI-assisted processes
 Description-Content-Type: text/markdown
 Requires-Dist: langfuse
@@ -19,6 +19,7 @@ Requires-Dist: pydantic
 Requires-Dist: pydantic_ai
 Requires-Dist: python-docx
 Requires-Dist: pymupdf4llm
+Requires-Dist: typer
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: requires-dist

ara_cli-0.1.10.1/ara_cli/__main__.py

@@ -0,0 +1,165 @@
+import typer
+import sys
+from typing import Optional
+from os import getenv
+from ara_cli.error_handler import AraError
+from ara_cli.version import __version__
+from ara_cli import error_handler
+from ara_cli.ara_subcommands.create import register as register_create_cli
+from ara_cli.ara_subcommands.delete import register as register_delete_cli
+from ara_cli.ara_subcommands.rename import register as register_rename_cli
+from ara_cli.ara_subcommands.list import register as register_list_cli
+from ara_cli.ara_subcommands.list_tags import register as register_list_tags_cli
+from ara_cli.ara_subcommands.prompt import register as register_prompt_cli
+from ara_cli.ara_subcommands.chat import register as register_chat_cli
+from ara_cli.ara_subcommands.template import register as register_template_cli
+from ara_cli.ara_subcommands.fetch_templates import register as register_fetch_templates_cli
+from ara_cli.ara_subcommands.read import register as register_read_cli
+from ara_cli.ara_subcommands.reconnect import register as register_reconnect_cli
+from ara_cli.ara_subcommands.read_status import register as register_read_status_cli
+from ara_cli.ara_subcommands.read_user import register as register_read_user_cli
+from ara_cli.ara_subcommands.set_status import register as register_set_status_cli
+from ara_cli.ara_subcommands.set_user import register as register_set_user_cli
+from ara_cli.ara_subcommands.classifier_directory import register as register_classifier_directory_cli
+from ara_cli.ara_subcommands.scan import register as register_scan_cli
+from ara_cli.ara_subcommands.autofix import register as register_autofix_cli
+from ara_cli.ara_subcommands.extract import register as register_extract_cli
+from ara_cli.ara_subcommands.load import register as register_load_cli
+
+
+def version_callback(value: bool):
+    if value:
+        typer.echo(f"ara {__version__}")
+        raise typer.Exit()
+
+
+def is_debug_mode_enabled():
+    """Check if debug mode is enabled via environment variable."""
+    return getenv('ARA_DEBUG', '').lower() in ('1', 'true', 'yes')
+
+
+def configure_debug_mode(debug: bool, env_debug_mode: bool):
+    """Configure debug mode based on arguments and environment."""
+    if debug or env_debug_mode:
+        error_handler.debug_mode = True
+
+
+def create_app():
+    app = typer.Typer(
+        help="""The ara cli terminal tool is a management tool for classified ara artefacts.
+
+Valid classified artefacts are: businessgoal, vision, capability, keyfeature, feature, epic, userstory, example, feature, task.
+
+The default ara directory structure of classified artefact of the ara cli tool is:
+.
+└── ara
+   ├── businessgoals
+   ├── capabilities
+   ├── epics
+   ├── examples
+   ├── features
+   ├── keyfeatures
+   ├── tasks
+   ├── userstories
+   └── vision
+
+ara artefact handling examples:
+  > create a new artefact for e.g. a feature:                                        ara create feature {feature_name}
+  > create a new artefact for e.g. a feature that contributes to an userstory:       ara create feature {feature_name} contributes-to userstory {story_name}
+  > read an artefact and return the content as terminal output, for eg. of a task:   ara read task {task_name}
+  > read an artefact and its full chain of contributions to its parents and return
+    the content as terminal output, for eg. of a task:                               ara read task {task_name} --branch
+  > delete an artefact for e.g. feature:                                             ara delete feature {feature_name}
+  > rename artefact and artefact data directory for e.g. a feature:                  ara rename feature {initial_feature_name} {new_feature_name}
+  > create additional templates for a specific aspect (valid aspects are: customer,
+    persona, concept, technology) related to an existing artefact like a feature:    ara create feature {feature_name} aspect {aspect_name}
+  > list artefact data with .md file extension                                       ara list --data {classifier} {artefact_name} --include-extension .md
+  > list artefact data with .md and .json file extensions                            ara list --data {classifier} {artefact_name} --include-extension .md .json
+  > list everything but userstories                                                  ara list --exclude-extension .userstory
+  > list all existing features:                                                      ara list --include-extension .feature
+  > 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}"
+  > list tasks which contain 'example content'                                       ara list --include-extension .task --include-content "example content"
+  > list children artefacts of a userstory                                           ara list --children userstory {name_of_userstory}
+  > list parent artefacts of a userstory                                             ara list --branch userstory {name_of_userstory}
+  > list parent businessgoal artefact of a userstory                                 ara list --branch userstory {name_of_userstory} --include-extension .businessgoal
+  > print any artefact template for e.g. a feature file template in the terminal:    ara template feature
+
+ara prompt templates examples:
+ > get and copy all prompt templates (blueprints, rules, intentions, commands
+   in the ara/.araconfig/global-prompt-modules directory:                            ara fetch-templates
+
+ara chat examples:
+  > chat with ara and save the default chat.md file in the working directory:        ara chat
+  > chat with ara and save the default task_chat.md file in the task.data directory: ara prompt chat task {task_name}
+
+  > initialize a macro prompt for a task:                                            ara prompt init task {task_name}
+  > load selected templates in config_prompt_templates.md for the task {task_name}:  ara prompt load task {task_name}
+  > create and send configured prompt of the task {task_name} to the configured LLM: ara prompt send task {task_name}
+  > extract the selected LLM response in task.exploration.md and save to disk:       ara prompt extract task {task_name}
+        """,
+        no_args_is_help=True,
+        add_completion=True,
+        rich_markup_mode="rich"
+    )
+
+    @app.callback(invoke_without_command=True)
+    def main(
+        ctx: typer.Context,
+        version: Optional[bool] = typer.Option(
+            None, "--version", "-v",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit"
+        ),
+        debug: bool = typer.Option(
+            False, "--debug",
+            help="Enable debug mode for detailed error output"
+        )
+    ):
+        """The ara cli terminal tool is a management tool for classified ara artefacts."""
+        debug_mode = is_debug_mode_enabled()
+        configure_debug_mode(debug, debug_mode)
+
+        # Only show help if no subcommand is invoked
+        if ctx.invoked_subcommand is None:
+            ctx.get_help()
+            ctx.exit()
+
+    # Register all commands
+    register_create_cli(app)
+    register_delete_cli(app)
+    register_rename_cli(app)
+    register_list_cli(app)
+    register_list_tags_cli(app)
+    register_prompt_cli(app)
+    register_chat_cli(app)
+    register_template_cli(app)
+    register_fetch_templates_cli(app)
+    register_read_cli(app)
+    register_reconnect_cli(app)
+    register_read_status_cli(app)
+    register_read_user_cli(app)
+    register_set_status_cli(app)
+    register_set_user_cli(app)
+    register_classifier_directory_cli(app)
+    register_scan_cli(app)
+    register_autofix_cli(app)
+    register_extract_cli(app)
+    register_load_cli(app)
+
+    return app
+
+
+def cli():
+    app = create_app()
+    try:
+        app()
+    except KeyboardInterrupt:
+        typer.echo("\n[INFO] Operation cancelled by user", err=True)
+        raise typer.Exit(130)  # Standard exit code for Ctrl+C
+    except Exception as e:
+        error_handler.handle_error(e, context="cli")
+
+
+if __name__ == "__main__":
+    cli()

{ara_cli-0.1.10.0 → ara_cli-0.1.10.1}/ara_cli/ara_command_action.py

@@ -130,9 +130,6 @@ def list_action(args):
         )
         return
 
-    if (args.tags):
-        artefact_lister.list_files(tags=args.tags, list_filter=list_filter)
-        return
     artefact_lister.list_files(list_filter=list_filter)
 
 
@@ -147,17 +144,25 @@ def list_tags_action(args):
     )
 
     tag_extractor = TagExtractor()
-    tags = tag_extractor.extract_tags(
+    tag_groups = tag_extractor.extract_tags(
         filtered_extra_column=getattr(args, "filtered_extra_column", False),
         list_filter=list_filter
     )
 
     if args.json:
-        output = json.dumps({"tags": tags})
+        all_tags = []
+        for group in tag_groups.values():
+            all_tags.extend(group)
+        output = json.dumps({"tags": sorted(all_tags)})
         print(output)
         return
 
-    output = "\n".join(f"- {tag}" for tag in tags)
+    output_lines = []
+    for key in sorted(tag_groups.keys()):
+        line = " ".join(sorted(list(tag_groups[key])))
+        output_lines.append(line)
+
+    output = "\n".join(f"- {tag}" for tag in output_lines)
     print(output)
 
 

ara_cli-0.1.10.1/ara_cli/ara_subcommands/autofix.py

@@ -0,0 +1,26 @@
+import typer
+from .common import MockArgs
+from ara_cli.ara_command_action import autofix_action
+
+
+def autofix_main(
+    single_pass: bool = typer.Option(False, "--single-pass", help="Run the autofix once for every scanned file"),
+    deterministic: bool = typer.Option(False, "-d", "--deterministic", help="Run only deterministic fixes e.g Title-FileName Mismatch fix"),
+    non_deterministic: bool = typer.Option(False, "-nd", "--non-deterministic", help="Run only non-deterministic fixes")
+):
+    """Fix ARA tree with llm models for scanned artefacts with ara scan command."""
+    if deterministic and non_deterministic:
+        typer.echo("Error: --deterministic and --non-deterministic are mutually exclusive", err=True)
+        raise typer.Exit(1)
+    
+    args = MockArgs(
+        single_pass=single_pass,
+        deterministic=deterministic,
+        non_deterministic=non_deterministic
+    )
+    autofix_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Fix ARA tree with llm models for scanned artefacts"
+    parent.command(name="autofix", help=help_text)(autofix_main)

ara_cli-0.1.10.1/ara_cli/ara_subcommands/chat.py

@@ -0,0 +1,27 @@
+import typer
+from typing import Optional, List
+from .common import MockArgs, ChatNameArgument
+from ara_cli.ara_command_action import chat_action
+
+
+def chat_main(
+    chat_name: Optional[str] = ChatNameArgument("Optional name for a specific chat. Pass the .md file to continue an existing 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")
+):
+    """Command line chatbot. Chat control with SEND/s | RERUN/r | QUIT/q"""
+    args = MockArgs(
+        chat_name=chat_name,
+        reset=reset,
+        output_mode=output_mode,
+        append=append,
+        restricted=restricted
+    )
+    chat_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Command line chatbot. Chat control with SEND/s | RERUN/r | QUIT/q"
+    parent.command(name="chat", help=help_text)(chat_main)

ara_cli-0.1.10.1/ara_cli/ara_subcommands/classifier_directory.py

@@ -0,0 +1,16 @@
+import typer
+from .common import ClassifierEnum, MockArgs, ClassifierArgument
+from ara_cli.ara_command_action import classifier_directory_action
+
+
+def classifier_directory_main(
+    classifier: ClassifierEnum = ClassifierArgument("Classifier of the artefact type")
+):
+    """Print the ara subdirectory for an artefact classifier."""
+    args = MockArgs(classifier=classifier.value)
+    classifier_directory_action(args)
+
+
+def register(parent: typer.Typer):
+    help_text = "Print the ara subdirectory for an artefact classifier"
+    parent.command(name="classifier-directory", help=help_text)(classifier_directory_main)

ara_cli-0.1.10.1/ara_cli/ara_subcommands/common.py

@@ -0,0 +1,100 @@
+from typing import Optional
+from enum import Enum
+import typer
+from ara_cli.classifier import Classifier
+from ara_cli.template_manager import SpecificationBreakdownAspects
+from ara_cli.completers import DynamicCompleters
+
+
+# Get classifiers and aspects
+classifiers = Classifier.ordered_classifiers()
+aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+
+
+# Create enums for better type safety
+ClassifierEnum = Enum('ClassifierEnum', {c: c for c in classifiers})
+AspectEnum = Enum('AspectEnum', {a: a for a in aspects})
+TemplateTypeEnum = Enum('TemplateTypeEnum', {
+    'rules': 'rules',
+    'intention': 'intention',
+    'commands': 'commands',
+    'blueprint': 'blueprint'
+})
+
+
+# Create typed arguments and options with autocompletion
+def ClassifierArgument(help_text: str, default=...):
+    """Create a classifier argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_classifier_completer()
+    )
+
+
+def ClassifierOption(help_text: str, *names):
+    """Create a classifier option with autocompletion."""
+    return typer.Option(
+        None,
+        *names,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_classifier_completer()
+    )
+
+
+def ArtefactNameArgument(help_text: str, default=...):
+    """Create an artefact name argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_artefact_name_completer()
+    )
+
+
+
+def ParentNameArgument(help_text: str):
+    """Create a parent name argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_parent_name_completer()
+    )
+
+
+def AspectArgument(help_text: str):
+    """Create an aspect argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_aspect_completer()
+    )
+
+
+def StatusArgument(help_text: str):
+    """Create a status argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_status_completer()
+    )
+
+
+def TemplateTypeArgument(help_text: str):
+    """Create a template type argument with autocompletion."""
+    return typer.Argument(
+        help=help_text,
+        autocompletion=DynamicCompleters.create_template_type_completer()
+    )
+
+
+def ChatNameArgument(help_text: str, default=None):
+    """Create a chat name argument with autocompletion."""
+    return typer.Argument(
+        default,
+        help=help_text,
+        autocompletion=DynamicCompleters.create_chat_file_completer()
+    )
+
+
+# Mock args class to maintain compatibility with existing action functions
+class MockArgs:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)

ara_cli-0.1.10.1/ara_cli/ara_subcommands/create.py

@@ -0,0 +1,75 @@
+import typer
+from typing import Optional
+from .common import (
+    ClassifierEnum, AspectEnum, MockArgs,
+    ClassifierArgument, ArtefactNameArgument, ParentNameArgument, AspectArgument
+)
+from ara_cli.ara_command_action import create_action
+
+
+def create_contributes_to(
+    ctx: typer.Context,
+    parent_classifier: ClassifierEnum = ClassifierArgument("Classifier of the parent"),
+    parent_name: str = ParentNameArgument("Name of a parent artefact"),
+    rule: Optional[str] = typer.Option(None, "-r", "--rule", help="Rule for contribution")
+):
+    """Create an artefact that contributes to a parent artefact."""
+    # Get classifier and parameter from parent context
+    parent_params = ctx.parent.params
+    classifier = parent_params['classifier']
+    parameter = parent_params['parameter']
+
+    args = MockArgs(
+        classifier=classifier,
+        parameter=parameter,
+        option="contributes-to",
+        parent_classifier=parent_classifier.value,
+        parent_name=parent_name,
+        rule=rule
+    )
+    create_action(args)
+
+
+def create_aspect(
+    ctx: typer.Context,
+    aspect: AspectEnum = AspectArgument("Adds additional specification breakdown aspects")
+):
+    """Create an artefact with additional specification breakdown aspects."""
+    # Get classifier and parameter from parent context
+    parent_params = ctx.parent.params
+    classifier = parent_params['classifier']
+    parameter = parent_params['parameter']
+
+    args = MockArgs(
+        classifier=classifier,
+        parameter=parameter,
+        option="aspect",
+        aspect=aspect.value
+    )
+    create_action(args)
+
+
+def create_main(
+    ctx: typer.Context,
+    classifier: ClassifierEnum = ClassifierArgument("Classifier that also serves as file extension"),
+    parameter: str = ArtefactNameArgument("Artefact name that serves as filename")
+):
+    """Create a classified artefact with data directory."""
+    if ctx.invoked_subcommand is None:
+        args = MockArgs(
+            classifier=classifier.value,
+            parameter=parameter,
+            option=None
+        )
+        create_action(args)
+
+
+def register(parent: typer.Typer):
+    create_app = typer.Typer(
+        help="Create a classified artefact with data directory",
+        add_completion=False  # Disable completion on subcommand
+    )
+    create_app.command("contributes-to")(create_contributes_to)
+    create_app.command("aspect")(create_aspect)
+    create_app.callback(invoke_without_command=True)(create_main)
+    parent.add_typer(create_app, name="create")

ara_cli-0.1.10.1/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-0.1.10.1/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-0.1.10.1/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-0.1.10.1/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-0.1.10.1/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-0.1.10.1/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)