ara-cli 0.1.9.77__py3-none-any.whl → 0.1.10.8__py3-none-any.whl

ara_cli/ara_config.py

@@ -1,254 +1,278 @@
 from typing import List, Dict, Optional, Any
-from pydantic import BaseModel, ValidationError, Field, field_validator, model_validator
+from pydantic import BaseModel, ValidationError, Field, model_validator
 import json
 import os
 from os.path import exists, dirname
 from os import makedirs
 from functools import lru_cache
 import sys
+import warnings
 
 DEFAULT_CONFIG_LOCATION = "./ara/.araconfig/ara_config.json"
 
+
 class LLMConfigItem(BaseModel):
     provider: str
     model: str
     temperature: float = Field(ge=0.0, le=1.0)
     max_tokens: Optional[int] = None
-    
-    @field_validator('temperature')
-    @classmethod
-    def validate_temperature(cls, v: float, info) -> float:
-        if not 0.0 <= v <= 1.0:
-            print(f"Warning: Temperature is outside the 0.0 to 1.0 range")
-            # Return a valid default
-            return 0.8
-        return v
+    max_completion_tokens: Optional[int] = None
 
-class ExtCodeDirItem(BaseModel):
-    source_dir: str
 
 class ARAconfig(BaseModel):
-    ext_code_dirs: List[ExtCodeDirItem] = Field(default_factory=lambda: [
-        ExtCodeDirItem(source_dir="./src"),
-        ExtCodeDirItem(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_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-4o": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4o",
-            temperature=0.8,
-            max_tokens=16384
-        ),
-        "gpt-4.1": LLMConfigItem(
-            provider="openai",
-            model="openai/gpt-4.1",
-            temperature=0.8,
-            max_tokens=1024
-        ),
-        "o3-mini": LLMConfigItem(
-            provider="openai",
-            model="openai/o3-mini",
-            temperature=1.0,
-            max_tokens=1024
-        ),
-        "opus-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-opus-4-20250514",
-            temperature=0.8,
-            max_tokens=32000
-        ),
-        "sonnet-4": LLMConfigItem(
-            provider="anthropic",
-            model="anthropic/claude-sonnet-4-20250514",
-            temperature=0.8,
-            max_tokens=1024
-        ),
-        "together-ai-llama-2": LLMConfigItem(
-            provider="together_ai",
-            model="together_ai/togethercomputer/llama-2-70b",
-            temperature=0.8,
-            max_tokens=1024
-        ),
-        "groq-llama-3": LLMConfigItem(
-            provider="groq",
-            model="groq/llama3-70b-8192",
-            temperature=0.8,
-            max_tokens=1024
-        )
-    })
-    default_llm: Optional[str] = "gpt-4o"
-    
-    model_config = {
-        "extra": "forbid"  # This will help identify unrecognized keys
-    }
-
-    @model_validator(mode='after')
-    def check_critical_fields(self) -> 'ARAconfig':
-        """Check for empty critical fields and use defaults if needed"""
+    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":
+        """Check for empty critical fields and validate default_llm and extraction_llm."""
         critical_fields = {
-            'ext_code_dirs': [ExtCodeDirItem(source_dir="./src"), ExtCodeDirItem(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 or 
-                (isinstance(current_value, list) and len(current_value) == 0) or
-                (isinstance(current_value, str) and current_value.strip() == "")):
-                print(f"Warning: Value for '{field}' is missing or empty.")
+            if not current_value:
+                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."
+            )
+            self.default_llm = None
+            self.extraction_llm = None
+            return self
+
+        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}'."
+            )
+            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
+
+        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
+
         return self
 
+
 # Function to ensure the necessary directories exist
 @lru_cache(maxsize=None)
 def ensure_directory_exists(directory: str):
+    """Creates a directory if it doesn't exist."""
     if not exists(directory):
         os.makedirs(directory)
         print(f"New directory created at {directory}")
     return directory
 
-def handle_unrecognized_keys(data: dict, known_fields: set) -> dict:
-    """Remove unrecognized keys and warn the user"""
+
+def handle_unrecognized_keys(data: dict) -> dict:
+    """Removes unrecognized keys from the data and warns the user."""
+    known_fields = set(ARAconfig.model_fields.keys())
     cleaned_data = {}
     for key, value in data.items():
         if key not in known_fields:
-            print(f"Warning: {key} is not recognized as a valid configuration option.")
+            print(f"Warning: Unrecognized configuration key '{key}' will be ignored.")
         else:
             cleaned_data[key] = value
     return cleaned_data
 
-def fix_llm_temperatures(data: dict) -> dict:
-    """Fix invalid temperatures in LLM configurations"""
-    if 'llm_config' in data:
-        for model_key, model_config in data['llm_config'].items():
-            if isinstance(model_config, dict) and 'temperature' in model_config:
-                temp = model_config['temperature']
-                if not 0.0 <= temp <= 1.0:
-                    print(f"Warning: Temperature for model '{model_key}' is outside the 0.0 to 1.0 range")
-                    model_config['temperature'] = 0.8
-    return data
-
-def validate_and_fix_config_data(filepath: str) -> dict:
-    """Load, validate, and fix configuration data"""
-    try:
-        with open(filepath, "r", encoding="utf-8") as file:
-            data = json.load(file)
-        
-        # Get known fields from the ARAconfig model
-        known_fields = set(ARAconfig.model_fields.keys())
-        
-        # Handle unrecognized keys
-        data = handle_unrecognized_keys(data, known_fields)
-        
-        # Fix LLM temperatures before validation
-        data = fix_llm_temperatures(data)
-        
-        return data
-    except json.JSONDecodeError as e:
-        print(f"Error: Invalid JSON in configuration file: {e}")
-        print("Creating new configuration with defaults...")
-        return {}
-    except Exception as e:
-        print(f"Error reading configuration file: {e}")
-        return {}
 
 # Function to read the JSON file and return an ARAconfig model
 @lru_cache(maxsize=1)
 def read_data(filepath: str) -> ARAconfig:
-    # Ensure the directory for the config file exists
-    config_dir = dirname(filepath)
-    ensure_directory_exists(config_dir)
+    """
+    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 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)
+            d[k] = v
+        return d
+
+    ensure_directory_exists(dirname(filepath))
 
     if not exists(filepath):
-        # If the file does not exist, create it with default values
+        print(f"Configuration file not found. Creating a default one at '{filepath}'.")
         default_config = ARAconfig()
         save_data(filepath, default_config)
-        print(
-            f"ara-cli configuration file '{filepath}' created with default configuration."
-            f" Please modify it as needed and re-run your command"
-        )
-        sys.exit(0)  # Exit the application
+        print("Please review the default configuration and re-run your command.")
+        sys.exit(0)
+
+    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)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in configuration file: {e}")
+        print("Creating a new configuration with defaults...")
+        default_config = ARAconfig()
+        save_data(filepath, default_config)
+        return default_config
+
+    data = handle_unrecognized_keys(data)
 
-    # Validate and load the existing configuration
-    data = validate_and_fix_config_data(filepath)
-    
     try:
-        # Try to create the config with the loaded data
         config = ARAconfig(**data)
-        
-        # Save the potentially fixed configuration back
         save_data(filepath, config)
-        
         return config
     except ValidationError as e:
-        print(f"ValidationError: {e}")
-        print("Correcting configuration with default values...")
-        
-        # Create a default config
-        default_config = ARAconfig()
-        
-        # Try to preserve valid fields from the original data
-        for field_name, field_value in data.items():
-            if field_name in ARAconfig.model_fields:
-                try:
-                    # Attempt to set the field value
-                    setattr(default_config, field_name, field_value)
-                except:
-                    # If it fails, keep the default
-                    pass
-        
-        # Save the corrected configuration
-        save_data(filepath, default_config)
-        print("Fixed configuration saved to file.")
-        
-        return default_config
+        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)
+        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
 
     @classmethod
-    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION):
+    def get_config(cls, filepath=DEFAULT_CONFIG_LOCATION) -> ARAconfig:
         if cls._config_instance is None:
-            config_dir = dirname(filepath)
-
-            if not exists(config_dir):
-                makedirs(config_dir)
-
             cls._config_instance = read_data(filepath)
         return cls._config_instance
-    
+
     @classmethod
     def reset(cls):
-        """Reset the configuration instance (useful for testing)"""
+        """Reset the configuration instance (useful for testing)."""
         cls._config_instance = None
-        read_data.cache_clear()
+        read_data.cache_clear()

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.template_manager import SpecificationBreakdownAspects
+from ara_cli.completers import DynamicCompleters
+
+
+# Get classifiers and aspects
+classifiers = Classifier.ordered_classifiers()
+aspects = SpecificationBreakdownAspects.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)