ara-cli 0.1.10.0__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/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/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/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/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.constants import VALID_ASPECTS
+from ara_cli.completers import DynamicCompleters
+
+
+# Get classifiers and aspects
+classifiers = Classifier.ordered_classifiers()
+aspects = 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)