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

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: ara_cli
-Version: 0.1.9.96
+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
 Requires-Dist: litellm
 Requires-Dist: llama-index
 Requires-Dist: llama-index-llms-openai
@@ -18,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.9.96 → ara_cli-0.1.10.1}/ara_cli/__init__.py

@@ -14,7 +14,7 @@ RESET = '\033[0m'
 
 
 def format_warning(message, category, *args, **kwargs):
-    return f'{YELLOW}{category.__name__}: {message}{RESET}\n'
+    return f'{YELLOW}[WARNING] {category.__name__}: {message}{RESET}\n'
 
 
 warnings.formatwarning = format_warning

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.9.96 → 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)
 
 
@@ -261,6 +266,59 @@ def chat_action(args):
     chat.start()
 
 
+def _find_chat_file(chat_name: str) -> str | None:
+    """Resolves the chat file path based on common naming conventions."""
+    # Logic from setup_chat for finding existing files.
+    if os.path.exists(chat_name) and os.path.isfile(chat_name):
+        return chat_name
+
+    chat_name_md = f"{chat_name}.md"
+    if os.path.exists(chat_name_md) and os.path.isfile(chat_name_md):
+        return chat_name_md
+
+    chat_name_chat_md = f"{chat_name}_chat.md"
+    if os.path.exists(chat_name_chat_md) and os.path.isfile(chat_name_chat_md):
+        return chat_name_chat_md
+
+    return None
+
+
+@handle_errors(context="load action", error_handler=error_handler)
+def load_action(args):
+    from ara_cli.template_loader import TemplateLoader
+
+    chat_name = args.chat_name
+    template_type = args.template_type
+    template_name = args.template_name
+
+    chat_file_path = _find_chat_file(chat_name)
+
+    if not chat_file_path:
+        raise AraError(f"Chat file for '{chat_name}' not found.")
+
+    default_patterns = {
+        "rules": "*.rules.md",
+        "intention": "*.intention.md",
+        "commands": "*.commands.md"
+    }
+
+    default_pattern = default_patterns.get(template_type)
+
+    if not template_name and not default_pattern:
+        raise AraError(f"A template name is required for template type '{template_type}'.")
+
+    loader = TemplateLoader()  # No chat instance for CLI context
+    success = loader.load_template(
+        template_name=template_name,
+        template_type=template_type,
+        chat_file_path=chat_file_path,
+        default_pattern=default_pattern
+    )
+
+    if not success:
+        sys.exit(1)
+
+
 @handle_errors(context="template action", error_handler=error_handler)
 def template_action(args):
     from ara_cli.classifier import Classifier
@@ -615,4 +673,4 @@ def extract_action(args):
         write=write,
         output=lambda msg: print(msg, file=sys.stdout)
     )
-    command.execute()
+    command.execute()

{ara_cli-0.1.9.96 → ara_cli-0.1.10.1}/ara_cli/ara_config.py

@@ -10,6 +10,7 @@ import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
+
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
@@ -17,6 +18,7 @@ class LLMConfigItem(BaseModel):
     max_tokens: Optional[int] = None
     max_completion_tokens: Optional[int] = None
 
+
 class ARAconfig(BaseModel):
     ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
         {"source_dir": "./src"},
@@ -28,98 +30,104 @@ class ARAconfig(BaseModel):
     local_prompt_templates_dir: str = "./ara/.araconfig"
     custom_prompt_templates_subdir: Optional[str] = "custom-prompt-modules"
     local_ara_templates_dir: str = "./ara/.araconfig/templates/"
-    ara_prompt_given_list_includes: List[str] = Field(default_factory=lambda: [
-        "*.businessgoal",
-        "*.vision",
-        "*.capability",
-        "*.keyfeature",
-        "*.epic",
-        "*.userstory",
-        "*.example",
-        "*.feature",
-        "*.task",
-        "*.py",
-        "*.md",
-        "*.png",
-        "*.jpg",
-        "*.jpeg",
-    ])
-    llm_config: Dict[str, LLMConfigItem] = Field(default_factory=lambda: {
-        "gpt-5": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5",
-            temperature=1,
-            max_completion_tokens=16000
-        ),
-        "gpt-5-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-5-mini-2025-08-07",
-            temperature=1
-        ),
-        "gpt-4o": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4o",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "gpt-4.1": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4.1",
-            temperature=0.8,
-            max_tokens=16000
-        ),
-        "o3-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/o3-mini",
-            temperature=1.0,
-            max_tokens=8000
-        ),
-        "opus-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-opus-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "sonnet-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-sonnet-4-20250514",
-            temperature=0.5,
-            max_tokens=32000
-        ),
-        "together-ai-llama-2": LLMConfigItem(
-            provider="together_ai",
-            model="together_ai/togethercomputer/llama-2-70b",
-            temperature=0.8,
-            max_tokens=4000
-        ),
-        "groq-llama-3": LLMConfigItem(
-            provider="groq",
-            model="groq/llama3-70b-8192",
-            temperature=0.8,
-            max_tokens=4000
-        )
-    })
+    ara_prompt_given_list_includes: List[str] = Field(
+        default_factory=lambda: [
+            "*.businessgoal",
+            "*.vision",
+            "*.capability",
+            "*.keyfeature",
+            "*.epic",
+            "*.userstory",
+            "*.example",
+            "*.feature",
+            "*.task",
+            "*.py",
+            "*.md",
+            "*.png",
+            "*.jpg",
+            "*.jpeg",
+        ]
+    )
+    llm_config: Dict[str, LLMConfigItem] = Field(
+        default_factory=lambda: {
+            "gpt-5": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-5",
+                temperature=1,
+                max_completion_tokens=16000,
+            ),
+            "gpt-5-mini": LLMConfigItem(
+                provider="openai", model="openai/gpt-5-mini-2025-08-07", temperature=1
+            ),
+            "gpt-4o": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4o",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "gpt-4.1": LLMConfigItem(
+                provider="openai",
+                model="openai/gpt-4.1",
+                temperature=0.8,
+                max_tokens=16000,
+            ),
+            "o3-mini": LLMConfigItem(
+                provider="openai",
+                model="openai/o3-mini",
+                temperature=1.0,
+                max_tokens=8000,
+            ),
+            "opus-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-opus-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "sonnet-4": LLMConfigItem(
+                provider="anthropic",
+                model="anthropic/claude-sonnet-4-20250514",
+                temperature=0.5,
+                max_tokens=32000,
+            ),
+            "together-ai-llama-2": LLMConfigItem(
+                provider="together_ai",
+                model="together_ai/togethercomputer/llama-2-70b",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+            "groq-llama-3": LLMConfigItem(
+                provider="groq",
+                model="groq/llama3-70b-8192",
+                temperature=0.8,
+                max_tokens=4000,
+            ),
+        }
+    )
     default_llm: Optional[str] = None
     extraction_llm: Optional[str] = None
 
-    @model_validator(mode='after')
-    def check_critical_fields(self) -> 'ARAconfig':
+    @model_validator(mode="after")
+    def check_critical_fields(self) -> "ARAconfig":
         """Check for empty critical fields and validate default_llm and extraction_llm."""
         critical_fields = {
-            'ext_code_dirs': [{"source_dir": "./src"}, {"source_dir": "./tests"}],
-            'local_ara_templates_dir': "./ara/.araconfig/templates/",
-            'local_prompt_templates_dir': "./ara/.araconfig",
-            'glossary_dir': "./glossary"
+            "ext_code_dirs": [{"source_dir": "./src"}, {"source_dir": "./tests"}],
+            "local_ara_templates_dir": "./ara/.araconfig/templates/",
+            "local_prompt_templates_dir": "./ara/.araconfig",
+            "glossary_dir": "./glossary",
         }
 
         for field, default_value in critical_fields.items():
             current_value = getattr(self, field)
             if not current_value:
-                print(f"Warning: Value for '{field}' is missing or empty. Using default.")
+                print(
+                    f"Warning: Value for '{field}' is missing or empty. Using default."
+                )
                 setattr(self, field, default_value)
-        
+
         if not self.llm_config:
-            print("Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set.")
+            print(
+                "Warning: 'llm_config' is empty. 'default_llm' and 'extraction_llm' cannot be set."
+            )
             self.default_llm = None
             self.extraction_llm = None
             return self
@@ -127,23 +135,34 @@ class ARAconfig(BaseModel):
         first_available_llm = next(iter(self.llm_config))
 
         if not self.default_llm:
-            print(f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: 'default_llm' is not set. Defaulting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
         elif self.default_llm not in self.llm_config:
-            print(f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'.")
-            print(f"-> Reverting to the first available model: '{first_available_llm}'.")
+            print(
+                f"Warning: The configured 'default_llm' ('{self.default_llm}') does not exist in 'llm_config'."
+            )
+            print(
+                f"-> Reverting to the first available model: '{first_available_llm}'."
+            )
             self.default_llm = first_available_llm
 
         if not self.extraction_llm:
-            print(f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'.")
+            print(
+                f"Warning: 'extraction_llm' is not set. Setting it to the same as 'default_llm': '{self.default_llm}'."
+            )
             self.extraction_llm = self.default_llm
         elif self.extraction_llm not in self.llm_config:
-            print(f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'.")
+            print(
+                f"Warning: The configured 'extraction_llm' ('{self.extraction_llm}') does not exist in 'llm_config'."
+            )
             print(f"-> Reverting to the 'default_llm' value: '{self.default_llm}'.")
             self.extraction_llm = self.default_llm
-            
+
         return self
 
+
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
 def ensure_directory_exists(directory: str):
@@ -153,6 +172,7 @@ def ensure_directory_exists(directory: str):
         print(f"New directory created at {directory}")
     return directory
 
+
 def handle_unrecognized_keys(data: dict) -> dict:
     """Removes unrecognized keys from the data and warns the user."""
     known_fields = set(ARAconfig.model_fields.keys())
@@ -211,13 +231,15 @@ def read_data(filepath: str) -> ARAconfig:
         return config
     except ValidationError as e:
         print("--- Configuration Error Detected ---")
-        print("Some settings in your configuration file are invalid. Attempting to fix them.")
-        
+        print(
+            "Some settings in your configuration file are invalid. Attempting to fix them."
+        )
+
         corrected_data = data.copy()
         defaults = ARAconfig().model_dump()
-        
-        error_fields = {err['loc'][0] for err in e.errors() if err['loc']}
-        
+
+        error_fields = {err["loc"][0] for err in e.errors() if err["loc"]}
+
         for field_name in error_fields:
             print(f"-> Field '{field_name}' is invalid and will be reverted to its default value.")
             if field_name in corrected_data:
@@ -228,15 +250,17 @@ def read_data(filepath: str) -> ARAconfig:
         final_config = ARAconfig(**corrected_data)
         save_data(filepath, final_config)
         print(f"Configuration has been corrected and saved to '{filepath}'.")
-        
+
         return final_config
 
+
 # Function to save the modified configuration back to the JSON file
 def save_data(filepath: str, config: ARAconfig):
     """Saves the Pydantic config model to a JSON file."""
     with open(filepath, "w", encoding="utf-8") as file:
         json.dump(config.model_dump(), file, indent=4)
 
+
 # Singleton for configuration management
 class ConfigManager:
     _config_instance = None
@@ -246,9 +270,9 @@ class ConfigManager:
         if cls._config_instance is None:
             cls._config_instance = read_data(filepath)
         return cls._config_instance
-    
+
     @classmethod
     def reset(cls):
         """Reset the configuration instance (useful for testing)."""
         cls._config_instance = None
-        read_data.cache_clear()
+        read_data.cache_clear()

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)