ara-cli 0.1.10.5__py3-none-any.whl → 0.1.14.0__py3-none-any.whl

ara_cli/ara_subcommands/convert.py

@@ -0,0 +1,107 @@
+import typer
+from typing import Optional
+
+from ara_cli import error_handler
+from ara_cli.completers import DynamicCompleters
+
+
+def register(app: typer.Typer):
+    @app.command()
+    def convert(
+        old_classifier: str = typer.Argument(
+            ...,
+            help=" The classifier of the source artefact",
+            autocompletion=DynamicCompleters.create_classifier_completer(),
+        ),
+        artefact_name: str = typer.Argument(
+            ...,
+            help="The name of the artefact to convert",
+            autocompletion=DynamicCompleters.create_convert_source_artefact_name_completer(),
+        ),
+        new_classifier: str = typer.Argument(
+            ...,
+            help="The target classifier",
+            autocompletion=DynamicCompleters.create_classifier_completer(),
+        ),
+        merge: bool = typer.Option(
+            False, "--merge", help="Merge with existing artefact if it exists"
+        ),
+        override: bool = typer.Option(
+            False, "--override", help="Override existing artefact if it exists"
+        ),
+        force: bool = typer.Option(
+            False,
+            "-f",
+            "--force",
+            help="When converting to task/issue, automatically clear children's contribution fields",
+        ),
+        json_output: bool = typer.Option(
+            False,
+            "-j",
+            "--json",
+            help="Output results as JSON (for API/non-interactive mode)",
+        ),
+        children_action: Optional[str] = typer.Option(
+            None,
+            "--children-action",
+            help="Non-interactive mode: Action for children (cancel/clear/reassign)",
+        ),
+        new_parent_classifier: Optional[str] = typer.Option(
+            None,
+            "--new-parent-classifier",
+            help="For reassign action: classifier of the new parent artefact",
+            autocompletion=DynamicCompleters.create_classifier_completer(),
+        ),
+        new_parent_name: Optional[str] = typer.Option(
+            None,
+            "--new-parent-name",
+            help="For reassign action: name of the new parent artefact",
+        ),
+        preview: bool = typer.Option(
+            False,
+            "--preview",
+            help="Preview children info without converting (returns JSON)",
+        ),
+    ):
+        """
+        Convert an existing artefact from one classifier to another.
+
+        For API/non-interactive mode, use --json and --children-action options.
+        Use --preview to get children information without performing conversion.
+        """
+        try:
+            from ara_cli.artefact_converter import AraArtefactConverter
+            from ara_cli.children_contribution_updater import (
+                ChildrenContributionUpdater,
+            )
+            import json
+
+            # Preview mode: return children info as JSON
+            if preview:
+                updater = ChildrenContributionUpdater()
+                info = updater.get_children_info(
+                    artefact_name, old_classifier, new_classifier
+                )
+                print(json.dumps(info, indent=2))
+                return
+
+            converter = AraArtefactConverter()
+            converter.convert(
+                old_classifier,
+                artefact_name,
+                new_classifier,
+                merge,
+                override,
+                force,
+                children_action=children_action,
+                new_parent_classifier=new_parent_classifier,
+                new_parent_name=new_parent_name,
+                json_output=json_output,
+            )
+        except Exception as e:
+            if json_output:
+                import json
+
+                print(json.dumps({"status": "error", "message": str(e)}))
+            else:
+                error_handler.handle_error(e)

ara_cli/ara_subcommands/fetch.py

@@ -0,0 +1,41 @@
+import typer
+
+
+def register(app: typer.Typer):
+    @app.command(
+        name="fetch",
+        help="Fetch templates, scripts, or agents. If no flags provided, fetches all.",
+    )
+    def fetch(
+        templates: bool = typer.Option(
+            False, "--templates", "-t", help="Fetch prompt templates only."
+        ),
+        scripts: bool = typer.Option(
+            False, "--scripts", "-s", help="Fetch scripts only."
+        ),
+        agents: bool = typer.Option(False, "--agents", "-a", help="Fetch agents only."),
+    ):
+        from ara_cli.commands.fetch_templates_command import FetchTemplatesCommand
+        from ara_cli.commands.fetch_scripts_command import FetchScriptsCommand
+        from ara_cli.commands.fetch_agents_command import FetchAgentsCommand
+
+        if not any([templates, scripts, agents]):
+            templates = True
+            scripts = True
+            agents = True
+            typer.echo("Fetching all resources (templates, scripts, agents)...")
+
+        if templates:
+            typer.echo("Fetching templates...")
+            command = FetchTemplatesCommand()
+            command.execute()
+
+        if scripts:
+            typer.echo("Fetching scripts...")
+            command = FetchScriptsCommand()
+            command.execute()
+
+        if agents:
+            typer.echo("Fetching agents...")
+            command = FetchAgentsCommand()
+            command.execute()

ara_cli/ara_subcommands/fetch_agents.py

@@ -0,0 +1,22 @@
+import typer
+
+
+def register(app: typer.Typer):
+    """Register the fetch-agents command with the typer app."""
+
+    @app.command(
+        name="fetch-agents",
+        help="Fetch binary agents from templates to project.",
+        deprecated=True,
+    )
+    def fetch_agents():
+        """Fetch binary agents from ara_cli/templates/agents to ara/.araconfig/agents."""
+        from ara_cli.commands.fetch_agents_command import FetchAgentsCommand
+
+        typer.secho(
+            "WARNING: 'fetch-agents' is deprecated. Please use 'ara fetch --agents' or just 'ara fetch' instead.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+        command = FetchAgentsCommand()
+        command.execute()

ara_cli/ara_subcommands/fetch_scripts.py

@@ -0,0 +1,19 @@
+import typer
+
+
+def register(app: typer.Typer):
+    @app.command(
+        name="fetch-scripts",
+        help="Fetch global scripts into your config directory.",
+        deprecated=True,
+    )
+    def fetch_scripts():
+        from ara_cli.commands.fetch_scripts_command import FetchScriptsCommand
+
+        typer.secho(
+            "WARNING: 'fetch-scripts' is deprecated. Please use 'ara fetch --scripts' or just 'ara fetch' instead.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+        command = FetchScriptsCommand()
+        command.execute()

ara_cli/ara_subcommands/fetch_templates.py

@@ -1,14 +1,19 @@
 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(app: typer.Typer):
+    @app.command(
+        name="fetch-templates",
+        help="Fetch global prompt templates into your config directory.",
+        deprecated=True,
+    )
+    def fetch_templates():
+        from ara_cli.commands.fetch_templates_command import FetchTemplatesCommand
 
-
-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)
+        typer.secho(
+            "WARNING: 'fetch-templates' is deprecated. Please use 'ara fetch --templates' or just 'ara fetch' instead.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+        command = FetchTemplatesCommand()
+        command.execute()

ara_cli/ara_subcommands/list.py

@@ -2,59 +2,133 @@ import typer
 from ara_cli.error_handler import AraError
 from typing import Optional, List, Tuple
 from .common import MockArgs
+from ara_cli.completers import DynamicCompleters
 from ara_cli.ara_command_action import list_action
 
 
-def _validate_extension_options(include_extension: Optional[List[str]], exclude_extension: Optional[List[str]]) -> None:
+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")
+        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:
+def _validate_exclusive_options(
+    branch: bool,
+    children: bool,
+    data: bool,
+) -> 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:
+    true_options = [opt for opt in exclusive_options if opt]
+    if len(true_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)")
+    classifier: Optional[str] = typer.Argument(
+        None,
+        help="The classifier of the artefact",
+        autocompletion=DynamicCompleters.create_classifier_completer(),
+    ),
+    artefact_name: Optional[str] = typer.Argument(
+        None,
+        help="The name of the artefact",
+        autocompletion=DynamicCompleters.create_artefact_name_completer(),
+    ),
+    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="List artefacts in the parent chain (requires classifier and artefact_name)",
+    ),
+    children: bool = typer.Option(
+        False,
+        "-c",
+        "--children",
+        help="List child artefacts (requires classifier and artefact_name)",
+    ),
+    data: bool = typer.Option(
+        False,
+        "-d",
+        "--data",
+        help="List file in the data directory (requires classifier and artefact_name)",
+    ),
 ):
     """List files with optional tags.
 
     Examples:
-        ara list --data feature my_feature --include-extension .md
+        ara list feature my_feature --data --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 userstory my_story --children
+        ara list userstory my_story --branch --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)
 
+    # If classifier is provided but no artefact_name, and no other specific flags are set,
+    # treat it as a filter by classifier (extension).
+    # This supports "ara list feature" -> lists all features.
+    if classifier and not artefact_name and not (branch or children or data):
+        # We append the classifier (prefixed with '.') to include_extension
+        # This assumes classifier names correspond to extensions (e.g. 'feature' -> '.feature')
+        # existing logic usually expects the extension format.
+        ext = f".{classifier}"
+        if include_extension:
+            include_extension.append(ext)
+        else:
+            include_extension = [ext]
+        # Clear classifier from args so it doesn't trigger other logic
+        classifier = None
+
     args = MockArgs(
+        classifier=classifier,
+        artefact_name=artefact_name,
         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)
+        branch=branch,
+        children=children,
+        data=data,
     )
 
     list_action(args)