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

ara_cli/ara_config.py

@@ -1,9 +1,9 @@
-from typing import List, Dict, Optional, Any
+from typing import List, Dict, Optional
 from pydantic import BaseModel, ValidationError, Field, model_validator
 import json
 import os
-from os.path import exists, dirname
 from os import makedirs
+from os.path import exists, dirname
 from functools import lru_cache
 import sys
 import warnings
@@ -14,21 +14,92 @@ DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
-    temperature: float = Field(ge=0.0, le=1.0)
+    temperature: Optional[float] = Field(ge=0.0, le=2.0)
     max_tokens: Optional[int] = None
     max_completion_tokens: Optional[int] = None
 
 
+def get_default_llm_config() -> Dict[str, "LLMConfigItem"]:
+    """Returns the default LLM configuration."""
+    return {
+        "gpt-5.2": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-5.2",
+            temperature=1,
+            max_completion_tokens=16000,
+        ),
+        "gpt-5-mini": LLMConfigItem(
+            provider="openai", model="openai/gpt-5-mini", temperature=1
+        ),
+        "gpt-5-web": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-5-search-api",
+            temperature=1,
+            max_completion_tokens=16000,
+        ),
+        "gpt-4o": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4o",
+            temperature=0.8,
+            max_tokens=16000,
+        ),
+        "gpt-4o-search-preview": LLMConfigItem(
+            provider="openai",
+            model="openai/gpt-4o-search-preview",
+            temperature=None,
+            max_tokens=None,
+            max_completion_tokens=None,
+        ),
+        "opus-4.5-advanced": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-opus-4-5-20251101",
+            temperature=0.5,
+            max_tokens=32000,
+        ),
+        "opus-4.1-exceptional": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-opus-4-1-20250805",
+            temperature=0.5,
+            max_tokens=32000,
+        ),
+        "sonnet-4.5-coding": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-sonnet-4-5-20250929",
+            temperature=0.5,
+            max_tokens=32000,
+        ),
+        "haiku-4-5": LLMConfigItem(
+            provider="anthropic",
+            model="anthropic/claude-haiku-4-5-20251001",
+            temperature=0.8,
+            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,
+        ),
+    }
+
+
 class ARAconfig(BaseModel):
-    ext_code_dirs: List[Dict[str, str]] = Field(default_factory=lambda: [
-        {"source_dir": "./src"},
-        {"source_dir": "./tests"}
-    ])
+    ext_code_dirs: List[Dict[str, str]] = Field(
+        default_factory=lambda: [{"source_dir": "./src"}, {"source_dir": "./tests"}]
+    )
     global_dirs: Optional[List[Dict[str, str]]] = Field(default=[])
     glossary_dir: str = "./glossary"
     doc_dir: str = "./docs"
     local_prompt_templates_dir: str = "./ara/.araconfig"
     custom_prompt_templates_subdir: Optional[str] = "custom-prompt-modules"
+    local_scripts_dir: str = "./ara/.araconfig"
+    custom_scripts_subdir: Optional[str] = "custom-scripts"
     local_ara_templates_dir: str = "./ara/.araconfig/templates/"
     ara_prompt_given_list_includes: List[str] = Field(
         default_factory=lambda: [
@@ -48,63 +119,26 @@ class ARAconfig(BaseModel):
             "*.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,
-            ),
-        }
-    )
+    # llm_config defaults to the standard set of models
+    llm_config: Dict[str, LLMConfigItem] = Field(default_factory=get_default_llm_config)
     default_llm: Optional[str] = None
     extraction_llm: Optional[str] = None
+    conversion_llm: Optional[str] = None
+
+    def _validate_llm_field(
+        self, field: str, fallback: str, missing_msg: str, invalid_msg: str
+    ):
+        """Helper to validate and set fallback for LLM fields."""
+        value = getattr(self, field)
+        if not value:
+            print(f"Warning: '{field}' is not set. {missing_msg}: '{fallback}'.")
+            setattr(self, field, fallback)
+        elif value not in self.llm_config:
+            print(
+                f"Warning: The configured '{field}' ('{value}') does not exist in 'llm_config'."
+            )
+            print(f"-> Reverting to {invalid_msg}: '{fallback}'.")
+            setattr(self, field, fallback)
 
     @model_validator(mode="after")
     def check_critical_fields(self) -> "ARAconfig":
@@ -113,12 +147,12 @@ class ARAconfig(BaseModel):
             "ext_code_dirs": [{"source_dir": "./src"}, {"source_dir": "./tests"}],
             "local_ara_templates_dir": "./ara/.araconfig/templates/",
             "local_prompt_templates_dir": "./ara/.araconfig",
+            "local_scripts_dir": "./ara/.araconfig",
             "glossary_dir": "./glossary",
         }
 
         for field, default_value in critical_fields.items():
-            current_value = getattr(self, field)
-            if not current_value:
+            if not getattr(self, field):
                 print(
                     f"Warning: Value for '{field}' is missing or empty. Using default."
                 )
@@ -132,33 +166,25 @@ class ARAconfig(BaseModel):
             self.extraction_llm = None
             return self
 
-        first_available_llm = next(iter(self.llm_config))
+        first_available = next(iter(self.llm_config))
+        self._validate_llm_field(
+            "default_llm",
+            first_available,
+            "Defaulting to the first available model",
+            "the first available model",
+        )
 
-        if not self.default_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}'."
-            )
-            self.default_llm = first_available_llm
+        # Now used as fallback for others
+        fallback_val = self.default_llm
+        fallback_missing_msg = "Setting it to the same as 'default_llm'"
+        fallback_invalid_msg = "the 'default_llm' value"
 
-        if not self.extraction_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"-> Reverting to the 'default_llm' value: '{self.default_llm}'.")
-            self.extraction_llm = self.default_llm
+        self._validate_llm_field(
+            "extraction_llm", fallback_val, fallback_missing_msg, fallback_invalid_msg
+        )
+        self._validate_llm_field(
+            "conversion_llm", fallback_val, fallback_missing_msg, fallback_invalid_msg
+        )
 
         return self
 
@@ -186,71 +212,101 @@ def handle_unrecognized_keys(data: dict) -> dict:
 
 
 # Function to read the JSON file and return an ARAconfig model
-@lru_cache(maxsize=1)
-def read_data(filepath: str) -> ARAconfig:
-    """
-    Reads, validates, and repairs the configuration file.
-    If the file doesn't exist, it creates a default one.
-    If the file is invalid, it corrects only the broken parts.
-    """
+
+
+def _create_default_config(filepath: str) -> ARAconfig:
+    """Create and save a default configuration."""
+    print(f"Configuration file not found. Creating a default one at '{filepath}'.")
+    default_config = ARAconfig(llm_config=get_default_llm_config())
+    save_data(filepath, default_config)
+    print("Please review the default configuration and re-run your command.")
+    sys.exit(0)
+
+
+def _load_json_config(filepath: str) -> dict:
+    """Load and parse JSON configuration file."""
 
     def warn_on_duplicate_llm_dict_key(ordered_pairs):
         """Reject duplicate keys."""
         d = {}
         for k, v in ordered_pairs:
             if k in d:
-                warnings.warn(f"Duplicate LLM configuration identifier '{k}'. The previous entry will be removed.", UserWarning)
+                warnings.warn(
+                    f"Duplicate LLM configuration identifier '{k}'. The previous entry will be removed.",
+                    UserWarning,
+                )
             d[k] = v
         return d
 
+    with open(filepath, "r", encoding="utf-8") as file:
+        content = file.read()
+        return json.loads(content, object_pairs_hook=warn_on_duplicate_llm_dict_key)
+
+
+def _correct_validation_errors(data: dict, errors: list) -> ARAconfig:
+    """Correct validation errors and return a valid config."""
+    print("--- Configuration Error Detected ---")
+    print(
+        "Some settings in your configuration file are invalid. Attempting to fix them."
+    )
+
+    corrected_data = data.copy()
+    defaults = ARAconfig(llm_config=get_default_llm_config()).model_dump()
+    error_fields = {err["loc"][0] for err in 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:
+            corrected_data[field_name] = defaults.get(field_name)
+
+    print("--- End of Error Report ---")
+    return ARAconfig(**corrected_data)
+
+
+@lru_cache(maxsize=1)
+def read_data(filepath: str) -> ARAconfig:
+    """
+    Reads, validates, and repairs the configuration file.
+    If the file doesn't exist, it creates a default one.
+    If the file is invalid, it corrects only the broken parts.
+    """
     ensure_directory_exists(dirname(filepath))
 
     if not exists(filepath):
-        print(f"Configuration file not found. Creating a default one at '{filepath}'.")
-        default_config = ARAconfig()
-        save_data(filepath, default_config)
-        print("Please review the default configuration and re-run your command.")
-        sys.exit(0)
+        return _create_default_config(filepath)
 
     try:
-        with open(filepath, "r", encoding="utf-8") as file:
-            content = file.read()
-            data = json.loads(content, object_pairs_hook=warn_on_duplicate_llm_dict_key)
+        data = _load_json_config(filepath)
     except json.JSONDecodeError as e:
         print(f"Error: Invalid JSON in configuration file: {e}")
         print("Creating a new configuration with defaults...")
-        default_config = ARAconfig()
+        default_config = ARAconfig(llm_config=get_default_llm_config())
         save_data(filepath, default_config)
         return default_config
 
     data = handle_unrecognized_keys(data)
 
+    needs_save = False
+    if "llm_config" not in data or not data.get("llm_config"):
+        print(
+            "Info: 'llm_config' is missing or empty. Populating with default LLM configurations."
+        )
+        data["llm_config"] = {
+            k: v.model_dump() for k, v in get_default_llm_config().items()
+        }
+        needs_save = True
+
     try:
         config = ARAconfig(**data)
-        save_data(filepath, config)
+        if needs_save:
+            save_data(filepath, config)
         return config
     except ValidationError as e:
-        print("--- Configuration Error Detected ---")
-        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"]}
-
-        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:
-                corrected_data[field_name] = defaults.get(field_name)
-
-        print("--- End of Error Report ---")
-
-        final_config = ARAconfig(**corrected_data)
+        final_config = _correct_validation_errors(data, e.errors())
         save_data(filepath, final_config)
         print(f"Configuration has been corrected and saved to '{filepath}'.")
-
         return final_config
 
 
@@ -266,9 +322,12 @@ class ConfigManager:
     _config_instance = None
 
     @classmethod
-    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION) -> ARAconfig:
+    def get_config(cls, filepath=None) -> ARAconfig:
+        if filepath:
+            return read_data(filepath)
+
         if cls._config_instance is None:
-            cls._config_instance = read_data(filepath)
+            cls._config_instance = read_data(DEFAULT_CONFIG_LOCATION)
         return cls._config_instance
 
     @classmethod

ara_cli/ara_subcommands/common.py

@@ -2,13 +2,13 @@ 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.constants import VALID_ASPECTS
 from ara_cli.completers import DynamicCompleters
 
 
 # Get classifiers and aspects
 classifiers = Classifier.ordered_classifiers()
-aspects = SpecificationBreakdownAspects.VALID_ASPECTS
+aspects = VALID_ASPECTS
 
 
 # Create enums for better type safety

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)