ara-cli 0.1.10.0__py3-none-any.whl → 0.1.13.3__py3-none-any.whl

ara_cli/ara_subcommands/config.py

@@ -0,0 +1,221 @@
+"""
+Config subcommand for ara-cli.
+Provides commands for managing ara configuration.
+"""
+import typer
+import os
+from typing import Optional
+
+config_app = typer.Typer(
+    help="Manage ara configuration",
+    no_args_is_help=True,
+)
+
+
+def _show_config_status(config_path: str, current_data: dict) -> None:
+    """Display current configuration status."""
+    import typer
+    typer.echo("Current configuration status:")
+    typer.echo(f"  Config file: {config_path}")
+    typer.echo(
+        f"  LLM configs: {len(current_data.get('llm_config', {}))} models defined")
+    typer.echo(f"  Default LLM: {current_data.get('default_llm', 'not set')}")
+    typer.echo(
+        f"  Extraction LLM: {current_data.get('extraction_llm', 'not set')}")
+    typer.echo("")
+    typer.echo("Use flags to reset specific parts:")
+    typer.echo("  --all          Reset everything")
+    typer.echo("  --llm-config   Reset LLM configurations")
+    typer.echo("  --default-llm  Reset default LLM selection")
+    typer.echo("  --paths        Reset directory paths")
+
+
+def _prepare_changes(
+    all_config: bool, llm_config: bool, default_llm: bool,
+    extraction_llm: bool, paths: bool, current_data: dict, defaults: dict
+) -> tuple[list, dict]:
+    """Prepare the list of changes and new data."""
+    changes = []
+    new_data = current_data.copy()
+
+    if all_config:
+        changes.append("All configuration values")
+        return changes, defaults.copy()
+
+    if llm_config:
+        changes.append("llm_config (LLM configurations)")
+        new_data["llm_config"] = defaults["llm_config"]
+
+    if default_llm:
+        first_llm = next(
+            iter(new_data.get("llm_config", defaults["llm_config"])))
+        changes.append(f"default_llm -> '{first_llm}'")
+        new_data["default_llm"] = first_llm
+
+    if extraction_llm:
+        target_llm = new_data.get("default_llm") or next(
+            iter(new_data.get("llm_config", defaults["llm_config"])))
+        changes.append(f"extraction_llm -> '{target_llm}'")
+        new_data["extraction_llm"] = target_llm
+
+    if paths:
+        path_fields = [
+            "ext_code_dirs", "global_dirs", "glossary_dir", "doc_dir",
+            "local_prompt_templates_dir", "local_scripts_dir", "local_ara_templates_dir",
+        ]
+        for field in path_fields:
+            if field in defaults:
+                new_data[field] = defaults[field]
+        changes.append(
+            "Directory paths (ext_code_dirs, glossary_dir, doc_dir, etc.)")
+
+    return changes, new_data
+
+
+def _apply_config_changes(config_path: str, new_data: dict) -> None:
+    """Validate and save configuration changes."""
+    import typer
+    from ara_cli.ara_config import ARAconfig, save_data, ConfigManager
+
+    validated_config = ARAconfig(**new_data)
+    save_data(config_path, validated_config)
+    ConfigManager.reset()
+
+    typer.echo("")
+    typer.echo("✓ Configuration reset successfully.")
+    typer.echo(f"  Saved to: {config_path}")
+
+
+@config_app.command("reset")
+def reset_config(
+    all_config: bool = typer.Option(
+        False, "--all", "-a", help="Reset entire configuration to defaults"),
+    llm_config: bool = typer.Option(
+        False, "--llm-config", help="Reset only llm_config to defaults"),
+    default_llm: bool = typer.Option(
+        False, "--default-llm", help="Reset only default_llm to first available LLM"),
+    extraction_llm: bool = typer.Option(
+        False, "--extraction-llm", help="Reset only extraction_llm to match default_llm"),
+    paths: bool = typer.Option(
+        False, "--paths", help="Reset directory paths to defaults"),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show what would be reset without making changes"),
+    yes: bool = typer.Option(False, "--yes", "-y",
+                             help="Skip confirmation prompt"),
+):
+    """
+    Reset ara configuration to default values.
+
+    If no flags are specified, shows current configuration status.
+    Use specific flags to reset only certain parts of the configuration.
+
+    Examples:
+        ara config reset --llm-config         # Reset only LLM configurations
+        ara config reset --all                # Reset everything to defaults
+        ara config reset --paths --dry-run    # Preview path reset without applying
+    """
+    from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION, ARAconfig, get_default_llm_config
+    import json
+
+    config_path = DEFAULT_CONFIG_LOCATION
+
+    if not os.path.exists(config_path):
+        typer.echo(f"Configuration file not found at '{config_path}'.")
+        typer.echo("Run any ara command to create a default configuration.")
+        raise typer.Exit(1)
+
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            current_data = json.load(f)
+    except json.JSONDecodeError as e:
+        typer.echo(f"Error reading configuration: {e}")
+        raise typer.Exit(1)
+
+    no_flags = not any(
+        [all_config, llm_config, default_llm, extraction_llm, paths])
+    if no_flags:
+        _show_config_status(config_path, current_data)
+        return
+
+    default_config = ARAconfig(llm_config=get_default_llm_config())
+    defaults = default_config.model_dump()
+
+    changes, new_data = _prepare_changes(
+        all_config, llm_config, default_llm, extraction_llm, paths, current_data, defaults
+    )
+
+    typer.echo("The following will be reset to defaults:")
+    for change in changes:
+        typer.echo(f"  • {change}")
+
+    if dry_run:
+        typer.echo("")
+        typer.echo("[Dry run - no changes made]")
+        return
+
+    if not yes:
+        typer.echo("")
+        if not typer.confirm("Proceed with reset?"):
+            typer.echo("Reset cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        _apply_config_changes(config_path, new_data)
+    except Exception as e:
+        typer.echo(f"Error saving configuration: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@config_app.command("show")
+def show_config(
+    llm_only: bool = typer.Option(
+        False,
+        "--llm",
+        help="Show only LLM configurations"
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output as JSON"
+    ),
+):
+    """
+    Show current ara configuration.
+
+    Examples:
+        ara config show              # Show full configuration
+        ara config show --llm        # Show only LLM configurations
+        ara config show --json       # Output as JSON
+    """
+    from ara_cli.ara_config import DEFAULT_CONFIG_LOCATION
+    import json
+
+    config_path = DEFAULT_CONFIG_LOCATION
+
+    if not os.path.exists(config_path):
+        typer.echo(f"Configuration file not found at '{config_path}'.")
+        raise typer.Exit(1)
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        config_data = json.load(f)
+
+    if llm_only:
+        output_data = {
+            "llm_config": config_data.get("llm_config", {}),
+            "default_llm": config_data.get("default_llm"),
+            "extraction_llm": config_data.get("extraction_llm"),
+        }
+    else:
+        output_data = config_data
+
+    if json_output:
+        typer.echo(json.dumps(output_data, indent=2))
+    else:
+        typer.echo(f"Configuration file: {config_path}")
+        typer.echo("")
+        typer.echo(json.dumps(output_data, indent=2))
+
+
+def register(app: typer.Typer):
+    """Register the config command group with the main app."""
+    app.add_typer(config_app, name="config")

ara_cli/ara_subcommands/convert.py

@@ -0,0 +1,43 @@
+import typer
+
+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"
+        ),
+    ):
+        """
+        Convert an existing artefact from one classifier to another.
+        """
+        try:
+            from ara_cli.artefact_converter import AraArtefactConverter
+
+            converter = AraArtefactConverter()
+            converter.convert(
+                old_classifier, artefact_name, new_classifier, merge, override
+            )
+        except Exception as e:
+            error_handler.handle_error(e)

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/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/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/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

@@ -0,0 +1,19 @@
+import typer
+
+
+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
+
+        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

@@ -0,0 +1,139 @@
+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:
+    """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: bool,
+    children: bool,
+    data: bool,
+) -> None:
+    """Validate that branch, children, and data options are mutually exclusive."""
+    exclusive_options = [branch, children, data]
+    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(
+    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 feature my_feature --data --include-extension .md
+        ara list --include-extension .feature
+        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=branch,
+        children=children,
+        data=data,
+    )
+
+    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)